SHARE
TWEET

test.log

logicmoo Sep 25th, 2019 166 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Starting
  2. Start main Total memory allocated to VM: 981MB.
  3. Start main Memory currently available: 939MB.
  4. Start main Memory currently used: 42MB.
  5. Using test dir w:\cyc\top\tests\
  6. Exists .\units\7166\unrepresented-terms.cfasl
  7. Exists .\data\caches\7166\generic-singular-nl-generation-fort-cache.fht
  8. Exists .\data\scg-repo-v2\service.properties
  9. Exists .\webapps\apps\webapp-manifest.xml
  10. Exists .\httpd\htdocs\javascript\similarity.js
  11. java.system.class.loader=null
  12. Armed Bear Common Lisp 1.6.0-uabcl (built Wed Sep 25 2019 00:19:50 PDT)
  13. Java 1.8.0_221 Oracle Corporation
  14. Java HotSpot(TM) 64-Bit Server VM
  15. Low-level initialization used 0.007 seconds.
  16. Startup completed in 2.551 seconds.
  17. Low-level initialization completed in 2.76 seconds.
  18. Warn: NOT redefining COMMON-LISP:* #<Primitive.pf_multiply * "&rest numbers" {5C74DAD4}> with #<SubLCompiledFunction * SubLSystemTrampolineFile.Numbers::multiply(&REST REST-LIST) {4C63D0DE}>
  19. Warn: Defining {dynamic special built-in-function CL:* -pf_multiply- ====> CL:NIL} not using {dynamic special built-in-function CL:* -pf_multiply- ====> CL:NIL}
  20. FOR: COMMON-LISP:*FEATURES*
  21. Found: file:/G:/opt/CYC_JRTL_with_CommonLisp/platform/lib/all-deps/org/objectweb/asm/MethodVisitor.class
  22. interface org.objectweb.asm.MethodVisitor
  23.  Loading implementation classes ...
  24.  ......... 10% ......... 20% ......... 30% ......... 40% ......... 50%
  25.  ......... 60% ......... 70% ......... 80% ......... 90% ......... 100%
  26.  Done.
  27. Low memory situations will be triggered when post-gc usage exceeds 9889MB(90% of 10913MB) for Heap memory pool PS Old Gen
  28. CollectionUsageThresholdSupported Total memory allocated to VM: 2006MB.
  29. CollectionUsageThresholdSupported Memory currently available: 1444MB.
  30. CollectionUsageThresholdSupported Memory currently used: 562MB.
  31. ERROR StatusLogger Log4j2 could not find a logging implementation. Please add log4j-core to the classpath. Using SimpleLogger to log to the console...
  32. ;;; loading init/jrtl-release-init.lisp ...
  33. ;;; CYC(1): (IN-PACKAGE "CYC")
  34. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  35. ;;; CYC(2): (CVS-ID "$Id: jrtl-release-init.lisp 129137 2009-11-05 03:40:25Z rck $")
  36. ;;; Result(2)  <==== CL:NIL
  37. ;;; CYC(3): (CSETQ *MASTER-LICENSE-KEY* "d928-2826-1787-5fe9-6d31")
  38. ;;; Result(3)  <==== d928-2826-1787-5fe9-6d31
  39. ;;; CYC(4): (PWHEN-FEATURE :CYC-RESEARCHCYC (PWHEN-FEATURE :SL2JAVA (CSETQ *MASTER-LICENSE-KEY* "d928-2826-1787-5fe9-6d31")))
  40. ;;; Result(4)  <==== d928-2826-1787-5fe9-6d31
  41. ;;; CYC(5): (PROGN (CSETQ *STANFORD-NER-HOST* "localhost") (CSETQ *STANFORD-NER-PORT* 6666) (PIF (FBOUNDP (QUOTE START-NER-SERVER)) (START-NER-SERVER *STANFORD-NER-PORT*) (CUNWIND-PROTECT (FORMAT T "Starting Named Entity Recognizer.~%") (RUN-EXTERNAL-PROCESS "java" (BQ-LIST "-server" "-Xmx1024m" "-XX:MaxPermSize=512m" "-cp" "data/parsers/stanford-ner-cyc-2006-09-18/stanford-ner.jar" "edu.stanford.nlp.ie.NERServer" "-loadClassifier" "data/parsers/stanford-ner-cyc-2006-09-18/classifiers/ner-eng-ie.crf-7-muc-distsim.ser.gz" (TO-STRING *STANFORD-NER-PORT*)) *NULL-INPUT* *NULL-OUTPUT* *ERROR-OUTPUT*) (SLEEP 20) (PROGN))))
  42. ;;; Result(5)  <==== CL:NIL
  43. ;;; CYC(6): (LOAD "init/jrtl-init.lisp")
  44. ;;; loading init/jrtl-init.lisp ...
  45. ;;; CYC(1): (IN-PACKAGE "CYC")
  46. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  47. ;;; CYC(2): (CVS-ID "$Id: jrtl-init.lisp 132325 2010-09-28 16:53:34Z rck $")
  48. ;;; Result(2)  <==== CL:NIL
  49. ;;; CYC(3): (LOAD-SYSTEM-PARAMETERS)
  50. ;;; Result(3)  <==== CL:NIL
  51. ;;; CYC(4): (SYSTEM-CODE-INITIALIZATIONS)
  52. Loading classifier from G:\opt\CYC_JRTL_with_CommonLisp\platform\data\parsers\stanford-ner-cyc-2006-09-18\classifiers\ner-eng-ie.crf-7-muc-distsim.ser.gz ... Initializing Cyc 10.152303 (ResearchCyc (custom))
  53. Warning: No KB is loaded.  System KB initializations will not be run.
  54. ;;; Result(4)  <==== CL:T
  55. ;;; CYC(5): (QUOTE (CLET ((UNITS-DIRECTORY "units/0988/")) (PIF (FBOUNDP (QUOTE CYC-LOAD-KB)) (CYC-LOAD-KB UNITS-DIRECTORY) (PROGN (LOAD-KB UNITS-DIRECTORY) (SYSTEM-CODE-INITIALIZATIONS)))))
  56. ;;; Result(5)  <==== (CLET ((UNITS-DIRECTORY "units/0988/")) (PIF (FBOUNDP (QUOTE CYC-LOAD-KB)) (CYC-LOAD-KB UNITS-DIRECTORY) (PROGN (LOAD-KB UNITS-DIRECTORY) (SYSTEM-CODE-INITIALIZATIONS))))
  57. ;;; CYC(6): (CLET ((UNITS-DIRECTORY "units/7166/")) (PIF (FBOUNDP (QUOTE CYC-LOAD-KB)) (CYC-LOAD-KB UNITS-DIRECTORY) (PROGN (LOAD-KB UNITS-DIRECTORY) (SYSTEM-CODE-INITIALIZATIONS))))
  58.  
  59.  
  60. ;;; Loading KB from units/7166/ at 09/25/2019 15:42:47
  61. Loading special objects ... DONE (0:00)
  62. Initializing HL backing store caches from units/7166/.
  63.  
  64. ;;; Loading essential KB at 09/25/2019 15:42:47
  65. Freeing clause-strucs ... DONE (0:00)
  66. Freeing KB HL supports ... DONE (0:00)
  67. Freeing deductions ... DONE (0:00)
  68. Freeing assertions ... DONE (0:00)
  69. Freeing NARTs ... DONE (0:00)
  70. Freeing constants ... DONE (0:00)
  71. Determining maximum unrepresented-term SUID ... DONE (0:00)
  72. Loading constant shells
  73.  [done [2.7 sec].
  74.  20% 30% 40% 50% 60% 80% 90% DONE (0:06) ]
  75. Enabling lazy assertion handle support ... DONE (0:00)
  76. Enabling lazy KB HL support handle support ... DONE (0:00)
  77. Loading clause-struc definitions
  78.  [ DONE (0:02) ]
  79. Deduction definitions will be swapped in lazily from
  80.    units/7166/deduction.cfasl
  81.    units/7166/deduction-index.cfasl
  82. Determining deduction max ID from index entries ... DONE (0:00)
  83. Enabling lazy deduction handle support ... DONE (0:00)
  84. Assertion definitions will be swapped in lazily from:
  85.    units/7166/assertion.cfasl
  86.    units/7166/assertion-index.cfasl
  87. KB HL supports will be swapped in lazily from:
  88.    units/7166/kb-hl-support.cfasl
  89.    units/7166/kb-hl-support-index.cfasl
  90. Loading bookkeeping assertions ... DONE (0:00)
  91. Loading rule utility experience ... DONE (0:01)
  92.  
  93. ;;; Loading computable KB at 09/25/2019 15:42:58
  94. Loading KB unrepresented terms
  95.  [01% (0:08 of ~13:20, ending ~09/25/19 15:56:18)
  96.   .... 10%.... 20%.... 30%.... 40%. 50% 60% 70% 80% 90% DONE (0:10) ]
  97. Constant indexing will be swapped in lazily from:
  98.    units/7166/indices.cfasl
  99.    units/7166/indices-index.cfasl
  100. Constant complex indexing will be swapped in lazily from:
  101.    units/7166/constant-complex-indices.cfasl
  102.    units/7166/constant-complex-indices-index.cfasl
  103. NART indexing will be swapped in lazily from:
  104.    units/7166/nat-indices.cfasl
  105.    units/7166/nat-indices-index.cfasl
  106. NART complex indexing will be swapped in lazily from:
  107.    units/7166/nat-complex-indices.cfasl
  108.    units/7166/nat-complex-indices-index.cfasl
  109. Unrepresented term indexing will be swapped in lazily from:
  110.    units/7166/unrepresented-term-indices.cfasl
  111.    units/7166/unrepresented-term-indices-index.cfasl
  112. Unrepresented complex term indexing will be swapped in lazily from:
  113.    units/7166/unrepresented-term-complex-indices.cfasl
  114.    units/7166/unrepresented-term-complex-indices-index.cfasl
  115. Loading assertion indices ... DONE (0:01)
  116. Loading auxiliary indices ... DONE (0:00)
  117. Loading bookkeeping indices ... DONE (0:00)
  118. Loading KB HL support indexing ... DONE (0:04)
  119. Loading rule set ... DONE (0:00)
  120. Loading non-true assertion tv cache ... DONE (0:00)
  121.  
  122. ;;; Loading computable remaining HL at 09/25/2019 15:43:14
  123. NART HL formulas will be swapped in lazily from:
  124.    units/7166/nart-hl-formula.cfasl
  125.    units/7166/nart-hl-formula-index.cfasl
  126. Loading miscellaneous stuff ... DONE (0:00)
  127. Loading SBHL graphs ... DONE (0:01)
  128. Loading SBHL time state ... DONE (0:01)
  129. Loading SBHL cache ... DONE (0:02)
  130. Loading cardinality estimates ... DONE (0:00)
  131. Loading arg-type cache ... DONE (0:00)
  132. Loading defns cache ... DONE (0:00)
  133. Loading somewhere cache ... DONE (0:00)
  134. Loading arity cache ... DONE (0:00)
  135. Loading TVA cache ... DONE (0:01)
  136. Loading reformulator rules ... DONE (0:00)
  137. Loading lexicon cache ... DONE (0:02)
  138. Loading RTP rules cache ... DONE (0:00)
  139. Initializing minor paraphrase CycL structures ... DONE (0:00)
  140. Loading pph-phrase shells ... DONE (0:00)
  141. Loading pph-phrase definitions
  142.  [ DONE (0:03) ]
  143. Loading #$genTemplate store ... DONE (0:00)
  144. Loading English units of measure ... DONE (0:00)
  145.  
  146. ;;; Performing KB initializations at 09/25/2019 15:43:25
  147. Computing bogus constant names in code ... DONE (0:00)
  148. Initializing some equality assertions somewhere ... DONE (0:01)
  149. Initializing #$interArgIsa cache
  150.  [ 20% 40% 60% 80% 100% DONE (0:15) ]
  151. Initializing #$interArgFormat cache ... DONE (0:00)
  152. Initializing old constant name table ... DONE (0:01)
  153. Initializing KB variables ... DONE (0:00)
  154.  
  155. ;;; Rebuilding computable-but-not-dumpable-yet-KB at 09/25/2019 15:43:47
  156. Swapping out assertion objects ... DONE (0:00)
  157. Swapping out deduction objects ... DONE (0:00)
  158. Swapping out constant-index objects ... DONE (0:00)
  159. Swapping out nart-index objects ... DONE (0:00)
  160. Swapping out nart-hl-formula objects ... DONE (0:00)
  161. Swapping out unrepresented-term-index objects ... DONE (0:00)
  162. Swapping out kb-hl-support objects ... DONE (0:00)
  163. Enforcing SBHL caching policies ... DONE (0:02)
  164.  
  165. ;;; Load of KB 7166 completed (1:03) at 09/25/2019 15:43:51
  166.  
  167. ;;; KB 7166 statistics
  168. FORTs                   :    638756
  169.  Constants              :    336790
  170.   cached indexing       :         0  (0%)
  171.  NARTs                  :    301966
  172.   cached indexing       :         0  (0%)
  173.   cached HL formulas    :         0  (0%)
  174. Assertions              :   9042563
  175.  KB Assertions          :   8469860
  176.   cached                :         0  (0%)
  177.  Bookkeeping Assertions :    572703
  178. Deductions              :  11218595
  179.   cached                :         0  (0%)
  180. KB HL supports          :   1348309
  181.   cached                :         0  (0%)
  182. Unrepresented terms     :   1100717
  183.   cached indexing       :         0  (0%)
  184. ;;; Result(6)  <==== 7166
  185. ;;; CYC(7): (PWHEN (FBOUNDP (QUOTE CL-IMPORTS-CYC)) (CL-IMPORTS-CYC))
  186. ;;; Result(7)  <==== CL:NIL
  187. ;;; CYC(8): (PWHEN (FBOUNDP (QUOTE CYC-IMPORTS-CL)) (CYC-IMPORTS-CL))
  188. ;; in pkg CYC Local Symbol CYC:FINALIZE will trump {built-in-function EXT:FINALIZE -pf_finalize-}.
  189. ;; in pkg CYC Local Symbol CYC:SOURCE will trump {built-in-function EXT:SOURCE -source-}.
  190. ;; in pkg CYC Local Symbol CYC:COLLECT will trump {EXT:COLLECT -MacroObject-}.
  191. ;; in pkg CYC Local Symbol CYC:MAILBOX will trump EXT:MAILBOX.
  192. ;; in pkg CYC Local Symbol CYC:MERGE will trump {CL:MERGE -sort_12-}.
  193. ;; in pkg CYC Local Symbol {CYC:NUMERATOR -SubLCompiledFunction-} will trump {built-in-function CL:NUMERATOR -pf_numerator-}.
  194. ;; in pkg CYC Local Symbol CYC:CONTINUE will trump {CL:CONTINUE -restart_60-}.
  195. ;; in pkg CYC Local Symbol CYC:DO will trump {CL:DO -sf_do-}.
  196. ;; in pkg CYC Local Symbol CYC:ABORT will trump {CL:ABORT -restart_58-}.
  197. ;; in pkg CYC Local Symbol CYC:PPRINT will trump {CL:PPRINT -pprint_155-}.
  198. ;; in pkg CYC Local Symbol CYC:MAP will trump {CL:MAP -Autoload-}.
  199. ;; in pkg CYC Local Symbol {CYC:FIND-IF-NOT -SubLCompiledFunction-} will trump {CL:FIND-IF-NOT -find_34-}.
  200. ;; in pkg CYC Local Symbol {CYC:VALUES-LIST -SubLCompiledFunction-} will trump {built-in-function CL:VALUES-LIST -pf_values_list-}.
  201. ;; in pkg CYC Local Symbol CYC:CLASS will trump CL:CLASS.
  202. ;; in pkg CYC Local Symbol {CYC:GCD -SubLCompiledFunction-} will trump {CL:GCD -Autoload-}.
  203. ;; in pkg CYC Local Symbol {CYC:TIME -SubLMacro-} will trump {CL:TIME -MacroObject-}.
  204. ;; in pkg CYC Local Symbol CYC:SLOT-VALUE will trump {CL:SLOT-VALUE -clos_92-}.
  205. ;; in pkg CYC Local Symbol CYC:WHEN will trump {CL:WHEN -sf_when-}.
  206. ;; in pkg CYC Local Symbol CYC:METHOD will trump CL:METHOD.
  207. ;; in pkg CYC Local Symbol CYC:ADD-METHOD will trump {CL:ADD-METHOD -FuncallableStandardObject-}.
  208. ;; in pkg CYC Local Symbol {CYC:ENSURE-DIRECTORIES-EXIST -SubLCompiledFunction-} will trump {CL:ENSURE-DIRECTORIES-EXIST -Autoload-}.
  209. ;; in pkg CYC Local Symbol CYC:THE will trump {CL:THE -sf_the-}.
  210. ;; in pkg CYC Local Symbol {CYC:DENOMINATOR -SubLCompiledFunction-} will trump {built-in-function CL:DENOMINATOR -pf_denominator-}.
  211. ;; in pkg CYC Local Symbol CYC:PATHNAME will trump {built-in-function CL:PATHNAME -pf_pathname-}.
  212. ;; in pkg CYC Local Symbol CYC:UNTRACE will trump {CL:UNTRACE -AutoloadMacro-}.
  213. ;; in pkg CYC Local Symbol CYC:SOME will trump {CL:SOME -early_defuns_21-}.
  214. ;; in pkg CYC Local Symbol CYC:ASSERT will trump {CL:ASSERT -AutoloadMacro-}.
  215. ;; in pkg CYC Local Symbol CYC:CLASS-OF will trump {built-in-function CL:CLASS-OF -pf_class_of-}.
  216. ;; in pkg CYC Local Symbol {CYC:LCM -SubLCompiledFunction-} will trump {CL:LCM -Autoload-}.
  217. ;; in pkg CYC Local Symbol CYC:PHASE will trump {CL:PHASE -Autoload-}.
  218. ;; in pkg CYC Local Symbol CYC:TRACE will trump {CL:TRACE -AutoloadMacro-}.
  219. ;; in pkg CYC Local Symbol CYC:POP will trump {CL:POP -MacroObject-}.
  220. ;; in pkg CYC Local Symbol CYC:COMPLEMENT will trump {CL:COMPLEMENT -list_9-}.
  221. ;; in pkg CYC Local Symbol CYC:LABELS will trump {CL:LABELS -sf_labels-}.
  222. ;; in pkg CYC Local Symbol CYC:STEP will trump {CL:STEP -AutoloadMacro-}.
  223. ;; in pkg CYC Local Symbol CYC:COND will trump {CL:COND -sf_cond-}.
  224. ;; in pkg CYC Local Symbol CYC:PUSH will trump {CL:PUSH -MacroObject-}.
  225. ;; in pkg CYC Local Symbol CYC:BLOCK will trump {CL:BLOCK -sf_block-}.
  226. ;;; Result(8)  <==== CL:NIL
  227. ;;; CYC(9): :EOF
  228. ;;; ... init/jrtl-init.lisp loaded; SHA-1: 32dc24b5e24e9c0e2a593964f7fd033a71a2a915
  229. ;;; Result(6)  <==== CL:T
  230. ;;; CYC(7): (LOAD "init/release-specific-init.lisp")
  231. ;;; loading init/release-specific-init.lisp ...
  232. ;;; CYC(1): (IN-PACKAGE :CYC)
  233. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  234. ;;; CYC(2): :EOF
  235. ;;; ... init/release-specific-init.lisp loaded; SHA-1: f7a2b3709b0377f49e804e5b7bceb2b712e21f9e
  236. ;;; Result(7)  <==== CL:T
  237. ;;; CYC(8): :EOF
  238. ;;; ... init/jrtl-release-init.lisp loaded; SHA-1: cf74cf49f5797741c766e535601a55de6f7dbe03
  239. Init Complete Total memory allocated to VM: 8069MB.
  240. Init Complete Memory currently available: 3997MB.
  241. Init Complete Memory currently used: 4071MB.
  242. Running all CycL unit tests.
  243. ;;; loading w:\cyc\top\tests\testdcl.lisp ...
  244. ;;; CYC(1): (IN-PACKAGE "CYC")
  245. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  246. ;;; CYC(2): (CVS-ID "$Id: testdcl.lisp 128793 2009-09-16 16:04:56Z pace $")
  247. ;;; Result(2)  <==== CL:NIL
  248. ;;; CYC(3): (DECLARE-CYC-TEST-FILE "stress-tests" :KB :BOTH)
  249. ;;; Result(3)  <==== #<CTF:stress-tests>
  250. ;;; CYC(4): (DECLARE-CYC-TEST-FILE "inference-unit-test-cases" :KB :BOTH)
  251. ;;; Result(4)  <==== #<CTF:inference-unit-test-cases>
  252. ;;; CYC(5): (DECLARE-CYC-TEST-FILE "inference-transformation-test-cases" :KB :BOTH)
  253. ;;; Result(5)  <==== #<CTF:inference-transformation-test-cases>
  254. ;;; CYC(6): (DECLARE-CYC-TEST-FILE "forward-inference-unit-test-cases" :KB :BOTH)
  255. ;;; Result(6)  <==== #<CTF:forward-inference-unit-test-cases>
  256. ;;; CYC(7): (DECLARE-CYC-TEST-FILE "inference-completeness-unit-test-cases" :KB :BOTH)
  257. ;;; Result(7)  <==== #<CTF:inference-completeness-unit-test-cases>
  258. ;;; CYC(8): (DECLARE-CYC-TEST-FILE "inference-proof-spec-test-cases" :KB :BOTH)
  259. ;;; Result(8)  <==== #<CTF:inference-proof-spec-test-cases>
  260. ;;; CYC(9): (DECLARE-CYC-TEST-FILE "inference-abduction-test-cases" :KB :BOTH)
  261. ;;; Result(9)  <==== #<CTF:inference-abduction-test-cases>
  262. ;;; CYC(10): (DECLARE-CYC-TEST-FILE "czer-unit-test-cases" :KB :BOTH)
  263. ;;; Result(10)  <==== #<CTF:czer-unit-test-cases>
  264. ;;; CYC(11): (DECLARE-CYC-TEST-FILE "kb-invariant-test-cases" :KB :BOTH)
  265. ;;; Result(11)  <==== #<CTF:kb-invariant-test-cases>
  266. ;;; CYC(12): (DECLARE-CYC-TEST-FILE "ist-rule-transformation-tests" :KB :BOTH)
  267. ;;; Result(12)  <==== #<CTF:ist-rule-transformation-tests>
  268. ;;; CYC(13): (DECLARE-CYC-TEST-FILE "pruning-tests" :KB :BOTH)
  269. ;;; Result(13)  <==== #<CTF:pruning-tests>
  270. ;;; CYC(14): (DECLARE-CYC-TEST-FILE "temporal-subsumption-unit-test-cases" :KB :FULL)
  271. ;;; Result(14)  <==== #<CTF:temporal-subsumption-unit-test-cases>
  272. ;;; CYC(15): (DECLARE-CYC-TEST-FILE "inference-rewrite-unit-test-cases" :KB :FULL)
  273. ;;; Result(15)  <==== #<CTF:inference-rewrite-unit-test-cases>
  274. ;;; CYC(16): (DECLARE-CYC-TEST-FILE "mt-unit-test-cases" :KB :FULL)
  275. ;;; Result(16)  <==== #<CTF:mt-unit-test-cases>
  276. ;;; CYC(17): (DECLARE-CYC-TEST-FILE "mt-tense-unit-test-cases" :KB :FULL)
  277. ;;; Result(17)  <==== #<CTF:mt-tense-unit-test-cases>
  278. ;;; CYC(18): (DECLARE-CYC-TEST-FILE "tense-czer-tests" :KB :FULL)
  279. ;;; Result(18)  <==== #<CTF:tense-czer-tests>
  280. ;;; CYC(19): (DECLARE-CYC-TEST-FILE "tva-cache-tests" :KB :FULL)
  281. ;;; Result(19)  <==== #<CTF:tva-cache-tests>
  282. ;;; CYC(20): (DECLARE-CYC-TEST-FILE "concatenate-strings-unit-test-cases" :KB :FULL)
  283. ;;; Result(20)  <==== #<CTF:concatenate-strings-unit-test-cases>
  284. ;;; CYC(21): (DECLARE-CYC-TEST-FILE "canonicalizer-test" :KB :BOTH)
  285. ;;; Result(21)  <==== #<CTF:canonicalizer-test>
  286. ;;; CYC(22): (DECLARE-CYC-TEST-FILE "czer-utilities-tests" :KB :BOTH)
  287. ;;; Result(22)  <==== #<CTF:czer-utilities-tests>
  288. ;;; CYC(23): (DECLARE-CYC-TEST-FILE "sequence-variables-tests" :KB :BOTH)
  289. ;;; Result(23)  <==== #<CTF:sequence-variables-tests>
  290. ;;; CYC(24): (DECLARE-CYC-TEST-FILE "elaboration-tolerance-tests" :KB :BOTH)
  291. ;;; Result(24)  <==== #<CTF:elaboration-tolerance-tests>
  292. ;;; CYC(25): (DECLARE-CYC-TEST-FILE "wff-tests" :KB :BOTH)
  293. ;;; Result(25)  <==== #<CTF:wff-tests>
  294. ;;; CYC(26): (DECLARE-CYC-TEST-FILE "wff-violation-tests" :KB :BOTH)
  295. ;;; Result(26)  <==== #<CTF:wff-violation-tests>
  296. ;;; CYC(27): (DECLARE-CYC-TEST-FILE "quoting-tests" :KB :BOTH)
  297. ;;; Result(27)  <==== #<CTF:quoting-tests>
  298. ;;; CYC(28): (DECLARE-CYC-TEST-FILE "uncanonicalizer-test" :KB :BOTH)
  299. ;;; Result(28)  <==== #<CTF:uncanonicalizer-test>
  300. ;;; CYC(29): (DECLARE-CYC-TEST-FILE "inference-tests" :KB :BOTH)
  301. ;;; Result(29)  <==== #<CTF:inference-tests>
  302. ;;; CYC(30): (DECLARE-CYC-TEST-FILE "tms-tests" :KB :BOTH)
  303. ;;; Result(30)  <==== #<CTF:tms-tests>
  304. ;;; CYC(31): (DECLARE-CYC-TEST-FILE "hl-storage-tests" :KB :BOTH)
  305. ;;; Result(31)  <==== #<CTF:hl-storage-tests>
  306. ;;; CYC(32): (DECLARE-CYC-TEST-FILE "api-tests" :KB :BOTH)
  307. ;;; Result(32)  <==== #<CTF:api-tests>
  308. ;;; CYC(33): (DECLARE-CYC-TEST-FILE "data-integrity" :KB :BOTH)
  309. ;;; Result(33)  <==== #<CTF:data-integrity>
  310. ;;; CYC(34): (DECLARE-CYC-TEST-FILE "cache-tests" :KB :BOTH)
  311. ;;; Result(34)  <==== #<CTF:cache-tests>
  312. ;;; CYC(35): (DECLARE-CYC-TEST-FILE "conjunctive-removal-module-tests" :KB :BOTH)
  313. ;;; Result(35)  <==== #<CTF:conjunctive-removal-module-tests>
  314. ;;; CYC(36): (DECLARE-CYC-TEST-FILE "transform-unify" :KB :BOTH)
  315. ;;; Result(36)  <==== #<CTF:transform-unify>
  316. ;;; CYC(37): (DECLARE-CYC-TEST-FILE "inference-harness-tests" :KB :BOTH)
  317. ;;; Result(37)  <==== #<CTF:inference-harness-tests>
  318. ;;; CYC(38): (DECLARE-CYC-TEST-FILE "seqvar-defn-tests" :KB :BOTH)
  319. ;;; Result(38)  <==== #<CTF:seqvar-defn-tests>
  320. ;;; CYC(39): (DECLARE-CYC-TEST-FILE "partition-tests" :KB :BOTH)
  321. ;;; Result(39)  <==== #<CTF:partition-tests>
  322. ;;; CYC(40): (DECLARE-CYC-TEST-FILE "indexing-tests" :KB :BOTH)
  323. ;;; Result(40)  <==== #<CTF:indexing-tests>
  324. ;;; CYC(41): (DECLARE-CYC-TEST-FILE "qa-test-cases" :KB :BOTH)
  325. ;;; Result(41)  <==== #<CTF:qa-test-cases>
  326. ;;; CYC(42): (DECLARE-CYC-TEST-FILE "kct-test-cases" :KB :BOTH)
  327. ;;; Result(42)  <==== #<CTF:kct-test-cases>
  328. ;;; CYC(43): (DECLARE-CYC-TEST-FILE "cyc-api-module-definition-tests" :KB :BOTH)
  329. ;;; Result(43)  <==== #<CTF:cyc-api-module-definition-tests>
  330. ;;; CYC(44): (DECLARE-CYC-TEST-FILE "quantity-test" :KB :BOTH)
  331. ;;; Result(44)  <==== #<CTF:quantity-test>
  332. ;;; CYC(45): (DECLARE-CYC-TEST-FILE "inference-parameter-tests" :KB :BOTH)
  333. ;;; Result(45)  <==== #<CTF:inference-parameter-tests>
  334. ;;; CYC(46): (DECLARE-CYC-TEST-FILE "similarity-tests" :KB :BOTH)
  335. ;;; Result(46)  <==== #<CTF:similarity-tests>
  336. ;;; CYC(47): (DECLARE-CYC-TEST-FILE "sbhl-inference-tests" :KB :BOTH)
  337. ;;; Result(47)  <==== #<CTF:sbhl-inference-tests>
  338. ;;; CYC(48): (DECLARE-CYC-TEST-FILE "min-genl-mts" :KB :BOTH)
  339. ;;; Result(48)  <==== #<CTF:min-genl-mts>
  340. ;;; CYC(49): (DECLARE-CYC-TEST-FILE "min-genl-predicates" :KB :BOTH)
  341. ;;; Result(49)  <==== #<CTF:min-genl-predicates>
  342. ;;; CYC(50): (DECLARE-CYC-TEST-FILE "min-genls-collection" :KB :BOTH)
  343. ;;; Result(50)  <==== #<CTF:min-genls-collection>
  344. ;;; CYC(51): (DECLARE-CYC-TEST-FILE "mutually-disjoint-with" :KB :BOTH)
  345. ;;; Result(51)  <==== #<CTF:mutually-disjoint-with>
  346. ;;; CYC(52): (DECLARE-CYC-TEST-FILE "sbhl-cache-test" :KB :BOTH)
  347. ;;; Result(52)  <==== #<CTF:sbhl-cache-test>
  348. ;;; CYC(53): (DECLARE-CYC-TEST-FILE "sdw-inference-tests" :KB :BOTH)
  349. ;;; Result(53)  <==== #<CTF:sdw-inference-tests>
  350. ;;; CYC(54): (DECLARE-CYC-TEST-FILE "transitive-via-arg" :KB :BOTH)
  351. ;;; Result(54)  <==== #<CTF:transitive-via-arg>
  352. ;;; CYC(55): (DECLARE-CYC-TEST-FILE "gt-test" :KB :BOTH)
  353. ;;; Result(55)  <==== #<CTF:gt-test>
  354. ;;; CYC(56): (DECLARE-CYC-TEST-FILE "sbhl-time-test" :KB :BOTH)
  355. ;;; Result(56)  <==== #<CTF:sbhl-time-test>
  356. ;;; CYC(57): (DECLARE-CYC-TEST-FILE "paraphrase" :KB :FULL)
  357. ;;; Result(57)  <==== #<CTF:paraphrase>
  358. ;;; CYC(58): (PWHEN-FEATURE :CYC-NL (DECLARE-CYC-TEST-FILE "phrase-structure-parser" :KB :FULL) (DECLARE-CYC-TEST-FILE "nl-generation-api-tests" :KB :FULL) (DECLARE-CYC-TEST-FILE "nl-parsing-api-tests" :KB :FULL))
  359. ;;; Result(58)  <==== #<CTF:nl-parsing-api-tests>
  360. ;;; CYC(59): (PWHEN-FEATURE :CYC-LEXICON (DECLARE-CYC-TEST-FILE "lexicon-access" :KB :FULL) (DECLARE-CYC-TEST-FILE "morphology-tests" :KB :FULL) (DECLARE-CYC-TEST-FILE "regular-morphological-forms" :KB :FULL) (DECLARE-CYC-TEST-FILE "regular-morphology" :KB :FULL))
  361. ;;; Result(59)  <==== #<CTF:regular-morphology>
  362. ;;; CYC(60): (PROGN (DECLARE-CYC-TEST-FILE "reformulator-test" :KB :FULL))
  363. ;;; Result(60)  <==== #<CTF:reformulator-test>
  364. ;;; CYC(61): (PWHEN-FEATURE :CYC-RKF (DECLARE-CYC-TEST-FILE "pred-strengthener" :KB :FULL) (DECLARE-CYC-TEST-FILE "rkf-term-reader" :KB :FULL))
  365. ;;; Result(61)  <==== #<CTF:rkf-term-reader>
  366. ;;; CYC(62): (PWHEN-FEATURE :CYC-SKSI (DECLARE-CYC-TEST-FILE "sksi-tests" :KB :FULL))
  367. ;;; Result(62)  <==== #<CTF:sksi-tests>
  368. ;;; CYC(63): (PWHEN-FEATURE :CYC-JAVAFRAMEWORK (DECLARE-CYC-TEST-FILE "analytical-tools" :KB :FULL))
  369. ;;; Result(63)  <==== #<CTF:analytical-tools>
  370. ;;; CYC(64): (PWHEN-FEATURE :CYC-BUTLER (DECLARE-CYC-TEST-FILE "ilp-tests" :KB :FULL))
  371. ;;; Result(64)  <==== #<CTF:ilp-tests>
  372. ;;; CYC(65): (DECLARE-CYC-TEST-FILE "removal-module-generic-test-cases" :KB :BOTH)
  373. ;;; Result(65)  <==== #<CTF:removal-module-generic-test-cases>
  374. ;;; CYC(66): (DECLARE-CYC-TEST-FILE "removal-module-specific-test-cases" :KB :BOTH)
  375. ;;; Result(66)  <==== #<CTF:removal-module-specific-test-cases>
  376. ;;; CYC(67): (DECLARE-CYC-TEST-FILE "transformation-module-test-cases" :KB :BOTH)
  377. ;;; Result(67)  <==== #<CTF:transformation-module-test-cases>
  378. ;;; CYC(68): (DECLARE-CYC-TEST-FILE "evaluatable-relation-test-cases" :KB :BOTH)
  379. ;;; Result(68)  <==== #<CTF:evaluatable-relation-test-cases>
  380. ;;; CYC(69): (DECLARE-CYC-TEST-FILE "removal-module-cost-test-cases" :KB :FULL)
  381. ;;; Result(69)  <==== #<CTF:removal-module-cost-test-cases>
  382. ;;; CYC(70): (DECLARE-CYC-TEST-FILE "transcript-tests" :KB :BOTH)
  383. ;;; Result(70)  <==== #<CTF:transcript-tests>
  384. ;;; CYC(71): (DECLARE-CYC-TEST-FILE "kb-swap-tests" :KB :FULL)
  385. ;;; Result(71)  <==== #<CTF:kb-swap-tests>
  386. ;;; CYC(72): (DECLARE-CYC-TEST-FILE "slow-tests" :KB :BOTH)
  387. ;;; Result(72)  <==== #<CTF:slow-tests>
  388. ;;; CYC(73): (DECLARE-CYC-TEST-FILE "sweep-tests" :KB :BOTH)
  389. ;;; Result(73)  <==== #<CTF:sweep-tests>
  390. ;;; CYC(74): (DECLARE-CYC-TEST-FILE "kb-content-post-build-tests" :KB :BOTH)
  391. ;;; Result(74)  <==== #<CTF:kb-content-post-build-tests>
  392. ;;; CYC(75): :EOF
  393. ;;; ... w:\cyc\top\tests\testdcl.lisp loaded; SHA-1: 3f48a434065a896bdadd18eecc9a3820cd807027
  394. ;;; loading w:\cyc\top\tests\stress-tests.lisp ...
  395. ;;; CYC(1): (IN-PACKAGE "CYC")
  396. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  397. ;;; CYC(2): (CVS-ID "$Id: stress-tests.lisp 126739 2008-12-23 03:42:57Z builder $")
  398. ;;; Result(2)  <==== CL:NIL
  399. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-PARADOX-DOESNT-CRASH-CYC :OWNER "pace" :BUG 2448 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-SET (#$and (#$equalSymbols ?RUSSELL-SET (#$TheSetOf ?X (#$not (#$elementOf ?X ?X)))) (#$elementOf ?RUSSELL-SET ?RUSSELL-SET))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 30)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON NIL :COMMENT "Test that Cyc doesn't crash while pondering the Russell Paradox.")
  400. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  401. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-COLLECTION-PARADOX-DOESNT-CRASH-CYC :OWNER "pace" :BUG 2448 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-COL (#$and (#$equalSymbols ?RUSSELL-COL (#$TheCollectionOf ?X (#$not (#$isa ?X ?X)))) (#$isa ?RUSSELL-COL ?RUSSELL-COL))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 30)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON NIL :COMMENT "Test that Cyc doesn't crash while pondering the collection version of the Russell Paradox.")
  402. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  403. ;;; CYC(5): (DEFINE-INFERENCE-TEST :HEINOUS-SKOLEMIZATION (:COMMENT "A heinous skolemization that used to crash Cyc because of
  404.       a circular list produced by a destructivity bug in skolemize-variable." :OWNER "pace" :BUG 20382 :KB :FULL) (FORM-VERIFY (FUNCTION EQ) T (QUOTE (BOOLEAN (CANONICALIZE-EL-SENTENCE (QUOTE (#$or (#$thereExistExactly (#$PlusAll (#$SetExtentFn (#$TheSetOf ?MID-PART-TYPE (#$thereExists ?SUB-PART-TYPE (#$and (#$or (#$isa ?OBJ ?FOCAL-PART-TYPE) (#$not (#$isa ?OBJ ?SUB-PART-TYPE))) (#$or (#$thereExists ?OTHER (#$and (#$isa ?OTHER ?SUB-PART-TYPE) (#$physicalParts ?TERM ?OTHER))) (#$not (#$isa ?TERM ?MID-PART-TYPE))) (#$or (#$thereExists ?OTHER (#$and (#$isa ?OTHER ?MID-PART-TYPE) (#$physicalParts ?TERM ?OTHER))) (#$not (#$isa ?TERM ?ORGANISM-TYPE))))))) (#$FunctionToArg 2 (#$Kappa (?MP-TYPE ?TOTAL) (#$thereExists ?SUB-PART-TYPE1 (#$thereExists ?SUB-NUM (#$thereExists ?MID-NUM (#$and (#$or (#$isa ?OBJ ?FOCAL-PART-TYPE) (#$not (#$isa ?OBJ ?SUB-PART-TYPE1))) (#$or (#$thereExistExactly ?MID-NUM ?OTHER (#$and (#$isa ?OTHER ?SUB-PART-TYPE1) (#$physicalParts ?TERM ?OTHER))) (#$not (#$isa ?TERM ?MP-TYPE))) (#$or (#$thereExistExactly ?SUB-NUM ?OTHER (#$and (#$isa ?OTHER ?MP-TYPE) (#$physicalParts ?TERM ?OTHER))) (#$not (#$isa ?TERM ?ORGANISM-TYPE))) (#$evaluate ?TOTAL (#$TimesFn ?MID-NUM ?SUB-NUM))))))))) ?OTHER (#$and (#$isa ?OTHER ?FOCAL-PART-TYPE) (#$anatomicalParts ?TERM ?OTHER))) (#$not (#$isa ?TERM ?ORGANISM-TYPE)))) #$BaseKB)))))
  405. ;;; Result(5)  <==== :HEINOUS-SKOLEMIZATION
  406. ;;; CYC(6): (DEFINE-INFERENCE-TEST :NAT-REIFICATION-INFINITE-RECURSION (:COMMENT "Test that forward inference doesn't trigger infinitely recursing nat reification" :OWNER "pace" :BUG 20521 :KB :FULL) (CLET ((RANDOM-STRING (STR (RANDOM 999999999))) (NAUT (BQ-LIST #$CollectionSubsetFn #$TerroristAttack (BQ-LIST #$TheSetOf (QUOTE ?EVENT) (BQ-LIST #$and (QUOTE (#$isa ?EVENT #$TerroristAttack)) (QUOTE (#$eventOccursAt ?EVENT #$Israel)) (BQ-LIST #$comment (QUOTE ?EVENT) RANDOM-STRING)))))) (CUNWIND-PROTECT (PROGN (FORM-VERIFY (FUNCTION EQ) T (BQ-LIST (QUOTE NART-P) (BQ-LIST (QUOTE CYC-CREATE-NART) (BQ-LIST (QUOTE QUOTE) NAUT))))) (CLET ((EXISTING-NART (FIND-NART NAUT))) (PWHEN EXISTING-NART (CYC-KILL EXISTING-NART))))))
  407. ;;; Result(6)  <==== :NAT-REIFICATION-INFINITE-RECURSION
  408. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-LINK-ACTIVATION-INFINITE-RECURSION :OWNER "pace" :BUG 21098 :KB :FULL :SENTENCE (QUOTE (#$ist #$TKBSourceSpindleCollectorMt (#$interestingSentence #$LebaneseHizballah ?SENTENCE))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :MAX-TIME 60)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON NIL :COMMENT "This used to cause an infinite recursion in
  409. balanced-strategy-activate-transformation-argument-links-wrt-transformation.")
  410. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  411. ;;; CYC(8): (DEFINE-INFERENCE-TEST :SUBLIS-IS-ITERATIVE (:COMMENT "Test that sublis isn't recursive on the cdr" :OWNER "pace" :BUG 18429 :KB :TINY) (CLET ((N 10000) (BIG-LIST (MAKE-LIST N #\a))) (SUBLIS (QUOTE ((#\b . 2))) BIG-LIST) (SUBLIS (QUOTE ((#\a . 1))) BIG-LIST) (CLET ((BIGGER-LIST (LIST BIG-LIST BIG-LIST))) (SUBLIS (QUOTE ((#\b . 2))) BIGGER-LIST) (SUBLIS (QUOTE ((#\a . 1))) BIGGER-LIST))))
  412. ;;; Result(8)  <==== :SUBLIS-IS-ITERATIVE
  413. ;;; CYC(9): (DEFINE-INFERENCE-TEST :NSUBLIS-IS-ITERATIVE (:COMMENT "Test that nsublis isn't recursive on the cdr" :OWNER "pace" :BUG 18429 :KB :TINY) (CLET ((N 10000) (BIG-LIST (MAKE-LIST N #\a))) (NSUBLIS (QUOTE ((#\b . 2))) (COPY-TREE BIG-LIST)) (NSUBLIS (QUOTE ((#\a . 1))) (COPY-TREE BIG-LIST)) (CLET ((BIGGER-LIST (LIST BIG-LIST BIG-LIST))) (NSUBLIS (QUOTE ((#\b . 2))) (COPY-TREE BIGGER-LIST)) (NSUBLIS (QUOTE ((#\a . 1))) (COPY-TREE BIGGER-LIST)))))
  414. ;;; Result(9)  <==== :NSUBLIS-IS-ITERATIVE
  415. ;;; CYC(10): (DEFINE-INFERENCE-TEST :DONT-CHOKE-THE-INFERENCE-CZER (:COMMENT "This used to crash due to cdr recursion in NSUBLIS (bug 18429)
  416. during inference czation (contiguize-hl-vars)" :OWNER "pace" :BUG 20908 :KB :FULL) (NEW-CYC-QUERY (QUOTE (#$ist #$InferencePSC (#$thereExists ?SET1 (#$thereExists ?SET2 (#$and (#$evaluate ?DIFF (#$SetOrCollectionDifferenceFn ?SET1 ?SET2)) (#$genls ?GOAL-TYPE #$KnowledgeAcquisitionGoal) (#$evaluate ?SET1 (#$SetExtentFn (#$TheSetOf ?SENTENCE1 (#$goalCategoryForAgent #$Cyc (#$thereExists ?TV (#$knows #$Cyc (#$sentenceTruth ?SENTENCE1 ?TV))) ?GOAL-TYPE)))) (#$evaluate ?SET2 (#$SetExtentFn (#$TheSetOf ?SENTENCE2 (#$thereExists ?Q-SENTENCE (#$thereExists ?TIME (#$thereExists ?EVALUATION (#$and (#$goalCategoryForAgent #$Cyc (#$thereExists ?TV (#$knows #$Cyc (#$sentenceTruth ?SENTENCE2 ?TV))) ?GOAL-TYPE) (#$and (#$means ?Q-SENTENCE ?SENTENCE2) (#$evaluationOfAs (#$EvaluationOfByOnFn ?Q-SENTENCE (#$SomeFn (#$SubCollectionNamedFn "Boris" #$Person)) ?TIME) (#$MtWithFocalContentSentenceFn ?Q-SENTENCE) ?EVALUATION))))))))))))))))
  417. ;;; Result(10)  <==== :DONT-CHOKE-THE-INFERENCE-CZER
  418. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :LOGIN-AS-JONC :OWNER "pace" :BUG 21607 :KB :FULL :SENTENCE (QUOTE (#$ist (#$MtSpace #$CycorpBusinessQueryMt (#$MtTimeWithGranularityDimFn #$Now #$TimePoint)) (#$cyclistPrimaryProject #$JonC ?PROJECT))) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON NIL :COMMENT "Believe it or not, this actually used to crash Cyc.")
  419. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  420. ;;; CYC(12): (DEFINE-INFERENCE-TEST :CONCURRENT-SBHL-ACCESSES-WORK (:COMMENT "Ensure that a plurality of concurrent read accesses to the SBHL are appropriately
  421.       handled by the backing store infrastructure." :OWNER "rck" :BUG 22770 :KB :FULL) (FORM-VERIFY (FUNCTION EQ) NIL (QUOTE (STRESS-TEST-SBHL-GRAPH-CONCURRENT-SWAPPING))))
  422. ;;; Result(12)  <==== :CONCURRENT-SBHL-ACCESSES-WORK
  423. ;;; CYC(13): (DEFINE-INFERENCE-TEST :CONCURRENT-SBHL-CACHE-STRATEGY-UPDATE-WORK (:COMMENT "Ensure that a plurality of concurrent read accesses to the SBHL are appropriately
  424.       handled by cache strategy infrastructure." :OWNER "rck" :BUG 22846 :KB :FULL) (FORM-VERIFY (FUNCTION EQ) NIL (QUOTE (STRESS-TEST-SBHL-GRAPH-CONCURRENT-CACHE-STRATEGY-UPDATE))))
  425. ;;; Result(13)  <==== :CONCURRENT-SBHL-CACHE-STRATEGY-UPDATE-WORK
  426. ;;; CYC(14): (DEFPARAMETER-PRIVATE *RECURSIVE-DEFN-COL* :UNINITIALIZED)
  427. ;;; Result(14)  <==== {dynamic special CYC:*RECURSIVE-DEFN-COL* ====> :UNINITIALIZED}
  428. ;;; CYC(15): (DEFINE-PRIVATE RECURSIVE-DEFN (OBJECT) (RET (BOOLEAN (NEW-CYC-QUERY (BQ-LIST #$isa OBJECT *RECURSIVE-DEFN-COL*)))))
  429. ;;; Result(15)  <==== {CYC:RECURSIVE-DEFN -SubLInterpretedFunction-}
  430. ;;; CYC(16): (DEFINE-INFERENCE-TEST :RECURSIVE-DEFN (:COMMENT "Test that a recursive defn doesn't crash Cyc" :OWNER "pace" :BUG 22779 :KB :TINY) (WITH-TEST-CONSTANTS T ((COL #$Collection)) (PRINT-ASSERT (BQ-LIST (BQ-LIST* #$defnIff COL (QUOTE ((#$SubLQuoteFn RECURSIVE-DEFN))))) #$BaseKB :MONOTONIC :FORWARD) (CLET ((*RECURSIVE-DEFN-COL* COL)) (NEW-CYC-QUERY (BQ-LIST #$isa 212 COL) #$BaseKB))))
  431. ;;; Result(16)  <==== :RECURSIVE-DEFN
  432. ;;; CYC(17): :EOF
  433. ;;; ... w:\cyc\top\tests\stress-tests.lisp loaded; SHA-1: eba832d91185bf297afed14e6231e43c03f6c3c8
  434. ;;; loading w:\cyc\top\tests\inference-unit-test-cases.lisp ...
  435. ;;; CYC(1): (IN-PACKAGE "CYC")
  436. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  437. ;;; CYC(2): (CVS-ID "$Id: inference-unit-test-cases.lisp 129050 2009-10-28 16:49:31Z pace $")
  438. ;;; Result(2)  <==== CL:NIL
  439. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :ILL-FORMED :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$InferencePSC (212 #$isa))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "Test that ill-formedness is handled correctly")
  440. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  441. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :ERROR :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (WITH-INFERENCE-ERROR-HANDLING (ERROR "zyxwvut")))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON (NEW-INFERENCE-ERROR-SUSPEND-STATUS "zyxwvut") :COMMENT "Test that the harness catches errors.  Make sure you don't have *inference-debug?* on.")
  442. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  443. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :EXHAUST-VS-EXHAUST-TOTAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$equalSymbols ?X 212))) :PROPERTIES (QUOTE (:MAX-PROOF-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:MAX-PROOF-DEPTH 1 :CONTINUABLE? NIL) :EXPECTED-RESULT (((?X . 212))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that demonstrates the difference between :exhaust and :exhaust-total .")
  444. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  445. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :SIMPLEST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$Collection #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "simplest test - single fully-bound removal")
  446. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  447. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :SIMPLEST-HYPOTHETICAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?X #$Individual) (#$isa ?X #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "simplest hypothetical test - single fully-bound removal")
  448. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  449. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :SIMPLEST-FAILING-HYPOTHETICAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?X #$Thing) (#$isa ?X #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "simplest failing hypothetical test - this should not be provable")
  450. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  451. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :SIMPLIFY-HYPOTHETICAL-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$implies (#$isa ?X #$Individual) (#$isa ?X #$Individual))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "simple hypothetical simplification")
  452. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  453. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :SIMPLIFY-HYPOTHETICAL-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$implies (#$isa ?X #$Individual) (#$isa ?X #$Individual))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "simple hypothetical simplification")
  454. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  455. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :GENLS-FAILING-HYPOTHETICAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?X #$Collection) (#$genls ?X #$Thing)) (#$genls ?X #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "a simple failing hypothetical test using #$genls instead of #$isa.
  456. This should not be provable.")
  457. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  458. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITHOUT-PROOF-MT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED 212)) (#$thereExists ?MT (#$and (#$evaluate ?MT (#$EvaluateSubLFn (#$SubLQuoteFn *MT*))) (#$assertedSentence (#$genlMt ?MT #$UniversalVocabularyMt))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that verifies that a consequent mt is not hypothesized if not needed.")
  459. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  460. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-ANECT-LIFTING :OWNER "goolsbey" :BUG 4707 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL-TYPE #$Collection) (#$genls ?COL-TYPE #$Collection) (#$isa ?IND-TYPE #$Collection) (#$genls ?IND-TYPE #$Individual) (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$arg1Isa ?PRED ?COL-TYPE)) (#$ist #$UniversalVocabularyMt (#$arg1Genl ?PRED ?IND-TYPE))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (?PRED ?TERM) (?PRED ?TERM))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "test that we can hypothesize a term that must meet an
  461. already existing argGenl constraint, and it needs to use
  462. ANECT lifting to be a collection in the #$UniversalVocabularyMt (bug #4707)")
  463. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  464. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-HYPOTHETICAL-ARG-GENL :OWNER "goolsbey" :WORKING? NIL :BUG 4885 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Collection) (#$arg1Genl ?PRED #$Microtheory) (?PRED ?TERM)) (?PRED ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-RESULT :EXHAUST-TOTAL :COMMENT "test that we can hypothesize a term that must meet an
  465. argGenl constraint, where the constraint itself is hypothesized.")
  466. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  467. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-REIFIABLE-NAT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?PRED #$UnaryPredicate) (?PRED (?FUNC "a"))) (?PRED (?FUNC "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries involving reifiable functions")
  468. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  469. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-EQUAL-SYMBOLS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$equalSymbols ?X #$Thing) (#$isa ?X ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries with equalSymbols literals")
  470. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  471. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-EQUAL-SYMBOLS-UNIFY :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$equalSymbols (#$isa #$Thing ?X) (#$isa #$Thing #$Thing)) (#$isa ?X ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries with equalSymbols literals with non-variables as top-level args")
  472. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  473. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-EQUAL-SYMBOLS-SEQVAR :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$equalSymbols (#$TheList . ?X) (#$TheList #$Thing)) (#$equals (#$TheList . ?X) (#$TheList #$Thing))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries with equalSymbols literals with sequence variables")
  474. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  475. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-EQUAL-SYMBOLS-SEQVAR-2 :OWNER "pace" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$equalSymbols (#$TheList . ?X) (#$TheList #$Thing)) (#$thereExists ?COL (#$and (#$elementOf ?COL (#$TheList . ?X)) (#$isa ?COL ?COL)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries with equalSymbols literals with sequence variables")
  476. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  477. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-EXISTENTIAL :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$thereExists ?X (#$isa ?X ?COL))) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "test that we can hypothesize queries with existential quantification in the antecedent")
  478. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  479. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :ILL-FORMED-WRT-ARITY :OWNER "jantos" :BUG 4308 :SENTENCE (QUOTE (#$ist #$InferencePSC (#$isa #$isa))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "Test that ill-formedness wrt arity is handled correctly.")
  480. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  481. ;;; CYC(22): (DEFINE-INFERENCE-UNIT-TEST :DONT-RELAX-ARG-TYPE-CONSTRAINTS-FOR-VARIABLES :OWNER "jantos" :BUG 4442 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?BELIEFS #$UnaryPredicate) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (?BELIEFS (#$forAll ?X (#$and (#$isa ?X #$Collection) (#$isa ?X #$Individual)))) (#$isa #$Thing #$Thing))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :TAUTOLOGY))) :COMMENT "Test that if arg-type constraints for variables are not
  482. relaxed, the wff-checker will deem the antecedent ill-formed.")
  483. ;;; Result(22)  <==== #<INFERENCE-UNIT-TEST 0>
  484. ;;; CYC(23): (DEFINE-INFERENCE-UNIT-TEST :RELAX-ARG-TYPE-CONSTRAINTS-FOR-VARIABLES :OWNER "jantos" :BUG 4442 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?BELIEFS #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (#$canonicalizerDirectiveForArg ?BELIEFS 1 #$RelaxArgTypeConstraintsForVariables))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (?BELIEFS (#$forAll ?X (#$and (#$isa ?X #$Collection) (#$isa ?X #$Individual)))) (#$isa #$Thing #$Thing))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that if arg-type constraints for variables are
  485. relaxed, the wff-checker will deem the antecedent well-formed
  486. and go on to successfully prove the consequent.")
  487. ;;; Result(23)  <==== #<INFERENCE-UNIT-TEST 0>
  488. ;;; CYC(24): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-IST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$and (#$ist #$BaseKB (#$genls ?SPEC #$BinaryRelation))))) :EXPECTED-RESULT-TEST (QUOTE NOT-EQ) :EXPECTED-RESULT NIL :COMMENT "This test used to be :REMOVAL-IST-POS-GAF
  489. in the old harness.  Now it is a test
  490. that #$ist is handled properly by the inference czer.")
  491. ;;; Result(24)  <==== #<INFERENCE-UNIT-TEST 0>
  492. ;;; CYC(25): (DEFINE-INFERENCE-UNIT-TEST :IST-THERE-EXISTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$and (#$ist #$BaseKB (#$thereExists ?SPEC (#$genls ?SPEC #$BinaryRelation)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "This test used to be :REMOVAL-IST-FORMULA-CHECK
  493. in the old harness.  It tests that #$ist works correctly
  494. with a nested #$thereExists.")
  495. ;;; Result(25)  <==== #<INFERENCE-UNIT-TEST 0>
  496. ;;; CYC(26): (DEFINE-INFERENCE-UNIT-TEST :IST-FOR-ALL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$and (#$ist #$BaseKB (#$forAll ?SPEC (#$genls ?SPEC #$BinaryRelation)))))) :EXPECTED-RESULT NIL :COMMENT "Make sure #$ist doesn't do something
  497. really stupid with nested #$forAlls.")
  498. ;;; Result(26)  <==== #<INFERENCE-UNIT-TEST 0>
  499. ;;; CYC(27): (DEFINE-INFERENCE-UNIT-TEST :IST-NOT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$and (#$ist #$BaseKB (#$not (#$genls #$Microtheory #$BinaryPredicate)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "This test used to be :REMOVAL-IST-NEG-GAF
  500. in the old harness.  It tests the distribution of
  501. #$ist over #$not.")
  502. ;;; Result(27)  <==== #<INFERENCE-UNIT-TEST 0>
  503. ;;; CYC(28): (DEFINE-INFERENCE-UNIT-TEST :IST-IN-WHAT-MTS-1 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$ist ?MT (#$genls #$BinaryPredicate #$Relation)))) :EXPECTED-RESULT-TEST (QUOTE NOT-EQ) :EXPECTED-RESULT NIL :COMMENT "What mts is this sentence true in?")
  504. ;;; Result(28)  <==== #<INFERENCE-UNIT-TEST 0>
  505. ;;; CYC(29): (DEFINE-INFERENCE-UNIT-TEST :IST-IN-WHAT-MTS-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist ?MT (#$genls #$BinaryPredicate #$Relation))) :EXPECTED-RESULT-TEST (QUOTE NOT-EQ) :EXPECTED-RESULT NIL :COMMENT "What mts is this sentence true in?")
  506. ;;; Result(29)  <==== #<INFERENCE-UNIT-TEST 0>
  507. ;;; CYC(30): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-YET-WHOLLY-UNINDEXED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?SET (#$and (#$equalSymbols ?TERM 212) (?TERM ?TERM ?TERM))))) :EXPECTED-RESULT NIL :COMMENT "Test to ensure that a closed yet wholly unindexed sentence can be handled.")
  508. ;;; Result(30)  <==== #<INFERENCE-UNIT-TEST 0>
  509. ;;; CYC(31): (DEFINE-PRIVATE STRATEGICALLY-POSSIBLE-IMPLIES-TACTICALLY-POSSIBLE-HELPER (PROBLEM STRATEGY) (RET (STRATEGICALLY-POSSIBLE-PROBLEM-P PROBLEM STRATEGY)))
  510. ;;; Result(31)  <==== {CYC:STRATEGICALLY-POSSIBLE-IMPLIES-TACTICALLY-POSSIBLE-HELPER -SubLInterpretedFunction-}
  511. ;;; CYC(32): (DEFINE-INFERENCE-UNIT-TEST :STRATEGICALLY-POSSIBLE-IMPLIES-TACTICALLY-POSSIBLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GENL-PRED #$UnaryPredicate) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (?GENL-PRED "a") (?SPEC-PRED "a")) (?GENL-PRED ?OBJ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-NUMBER 1)) :EXPECTED-RESULT (QUOTE (((?OBJ . "a")))) :EXPECTED-HALT-REASON :MAX-NUMBER :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CMULTIPLE-VALUE-BIND (PROBLEM STRATEGY) (PREVIOUS-QUERY-ROOT-PROBLEM-AND-STRATEGY) (CAND (STRATEGICALLY-POSSIBLE-IMPLIES-TACTICALLY-POSSIBLE-HELPER PROBLEM STRATEGY) (TACTICALLY-POSSIBLE-PROBLEM-P PROBLEM)))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A strategically possible problem should also be tactically possible.")
  512. ;;; Result(32)  <==== #<INFERENCE-UNIT-TEST 0>
  513. ;;; CYC(33): (DEFINE-INFERENCE-UNIT-TEST :TACTICALLY-FINISHED-IMPLIES-STRATEGICALLY-FINISHED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$evaluate 3 (#$PlusFn 1 1)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CMULTIPLE-VALUE-BIND (PROBLEM STRATEGY) (PREVIOUS-QUERY-ROOT-PROBLEM-AND-STRATEGY) (CAND (TACTICALLY-FINISHED-PROBLEM-P PROBLEM) (STRATEGICALLY-FINISHED-PROBLEM-P PROBLEM STRATEGY)))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A tactically finished problem should also be strategically finished.")
  514. ;;; Result(33)  <==== #<INFERENCE-UNIT-TEST 0>
  515. ;;; CYC(34): (DEFINE-INFERENCE-UNIT-TEST :TACTICALLY-NO-GOOD-IMPLIES-STRATEGICALLY-NO-GOOD :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$evaluate 3 (#$PlusFn 1 1)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CMULTIPLE-VALUE-BIND (PROBLEM STRATEGY) (PREVIOUS-QUERY-ROOT-PROBLEM-AND-STRATEGY) (CAND (TACTICALLY-NO-GOOD-PROBLEM-P PROBLEM) (STRATEGICALLY-NO-GOOD-PROBLEM-P PROBLEM STRATEGY)))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A tactically no-good problem should also be strategically no-good.")
  516. ;;; Result(34)  <==== #<INFERENCE-UNIT-TEST 0>
  517. ;;; CYC(35): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-SPLIT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?IND #$Individual)) (#$and (#$isa ?IND #$Individual) (#$isa ?COL #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT ":split (independent #$and)")
  518. ;;; Result(35)  <==== #<INFERENCE-UNIT-TEST 0>
  519. ;;; CYC(36): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-UNION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$elementOf #$Collection (#$TheSet #$Individual)) (#$elementOf #$Collection (#$TheSet #$Collection))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT ":union (independent #$or)")
  520. ;;; Result(36)  <==== #<INFERENCE-UNIT-TEST 0>
  521. ;;; CYC(37): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-WITH-GENL-PREDS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?IND #$Individual) (#$isa ?GENERALIZATIONS #$TransitiveBinaryPredicate) (#$genlPreds #$genls ?GENERALIZATIONS)) (#$and (#$isa ?IND #$Individual) (?GENERALIZATIONS ?COL #$Individual))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT ":split with genlPreds")
  522. ;;; Result(37)  <==== #<INFERENCE-UNIT-TEST 0>
  523. ;;; CYC(38): (DEFINE-INFERENCE-UNIT-TEST :ONE-BINDING-LIST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$evaluate ?X (#$PlusFn 1 211)))) :EXPECTED-RESULT (QUOTE (((?X . 212)))) :COMMENT "a single answer for a non-fully-bound query")
  524. ;;; Result(38)  <==== #<INFERENCE-UNIT-TEST 0>
  525. ;;; CYC(39): (DEFINE-INFERENCE-UNIT-TEST :TWO-BINDING-LISTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$elementOf ?X (#$TheSet #$Collection #$Individual)))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection)) ((?X . #$Individual)))) :COMMENT "two answers for a non-fully-bound-query")
  526. ;;; Result(39)  <==== #<INFERENCE-UNIT-TEST 0>
  527. ;;; CYC(40): (DEFINE-INFERENCE-UNIT-TEST :TWO-VARS-ONE-BINDING-LIST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$evaluate ?X (#$PlusFn 1 211)) (#$evaluate ?Y (#$PlusFn 1 41))))) :EXPECTED-RESULT (QUOTE (((?X . 212) (?Y . 42)))) :COMMENT "a single answer for a set of two variables")
  528. ;;; Result(40)  <==== #<INFERENCE-UNIT-TEST 0>
  529. ;;; CYC(41): (DEFINE-INFERENCE-UNIT-TEST :TWO-TIMES-TWO :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf ?X (#$TheSet #$Thing #$Cyclist)) (#$elementOf ?Y (#$TheSet #$Collection #$Individual))))) :EXPECTED-RESULT (QUOTE (((?X . #$Thing) (?Y . #$Collection)) ((?X . #$Thing) (?Y . #$Individual)) ((?X . #$Cyclist) (?Y . #$Collection)) ((?X . #$Cyclist) (?Y . #$Individual)))) :COMMENT "two times two answers for a non-fully-bound-query")
  530. ;;; Result(41)  <==== #<INFERENCE-UNIT-TEST 0>
  531. ;;; CYC(42): (DEFINE-INFERENCE-UNIT-TEST :3-WAY-SPLIT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Thing #$Collection) (#$isa #$Individual #$Collection) (#$isa #$Collection #$Collection)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Three-way split")
  532. ;;; Result(42)  <==== #<INFERENCE-UNIT-TEST 0>
  533. ;;; CYC(43): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-NEGATED-SPLIT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$not (#$isa #$Collection #$Individual)) (#$not (#$isa #$Thing #$Individual))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Two-way negated split")
  534. ;;; Result(43)  <==== #<INFERENCE-UNIT-TEST 0>
  535. ;;; CYC(44): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-NEGATED-SPLIT-UNIFY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$isa #$Thing #$Collection) (#$equalSymbols ?WHAT #$Individual) (#$not (#$isa #$Collection ?WHAT)) (#$not (#$isa #$Thing ?WHAT))))) :EXPECTED-RESULT (QUOTE (((?WHAT . #$Individual)))) :COMMENT "Two-way negated split unify")
  536. ;;; Result(44)  <==== #<INFERENCE-UNIT-TEST 0>
  537. ;;; CYC(45): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-WITH-ADDITIONAL-SUPPORTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?OBJ-1 ?COL) (#$isa ?OBJ-2 ?COL) (#$isa ?GENL-PRED #$UnaryPredicate) (#$isa ?MID-PRED #$UnaryPredicate) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$genlPreds ?MID-PRED ?GENL-PRED) (#$genlPreds ?SPEC-PRED ?MID-PRED) (?SPEC-PRED ?OBJ-1)) (#$and (?GENL-PRED ?OBJ-1) (?MID-PRED ?X) (#$isa ?Y ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?OBJ-1) (?Y . ?OBJ-1)) ((?X . ?OBJ-1) (?Y . ?OBJ-2)))) :COMMENT "Split that includes additional HL supports for some sentences.  
  538.    This caused the old harness to crash by not copying the list of additional HL supports
  539.    when constructing inference answers.")
  540. ;;; Result(45)  <==== #<INFERENCE-UNIT-TEST 0>
  541. ;;; CYC(46): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-SPLIT-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X ?Y) (#$different ?X ?Y)))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Split where both branches are impossible")
  542. ;;; Result(46)  <==== #<INFERENCE-UNIT-TEST 0>
  543. ;;; CYC(47): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-SPLIT-PRUNE-EXHAUST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$implies (#$isa ?A ?B) (?P ?A ?B))) (#$and (?P ?X ?Y) (#$different ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Split where both branches are impossible
  544. but it could potentially be continued into something possible")
  545. ;;; Result(47)  <==== #<INFERENCE-UNIT-TEST 0>
  546. ;;; CYC(48): (DEFINE-INFERENCE-UNIT-TEST :IMPOSSIBLE-SPLIT-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X ?Y) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Split where one branch is impossible -- it should never
  547. try the possible branch for tactical reasons")
  548. ;;; Result(48)  <==== #<INFERENCE-UNIT-TEST 0>
  549. ;;; CYC(49): (DEFINE-INFERENCE-UNIT-TEST :FALSE-SPLIT-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Thing #$Individual) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Like :impossible-split-prune except the easy branch is provably
  550. false instead of just impossible.")
  551. ;;; Result(49)  <==== #<INFERENCE-UNIT-TEST 0>
  552. ;;; CYC(50): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SPLIT-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$Predicate) (#$and (#$isa ?PRED #$BinaryPredicate) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Like :impossible-split-prune except the easy branch is not provable,
  553. and its negation is not provable either.")
  554. ;;; Result(50)  <==== #<INFERENCE-UNIT-TEST 0>
  555. ;;; CYC(51): (DEFINE-INFERENCE-UNIT-TEST :IMPOSSIBLE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X ?Y) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :EXPECTED-RESULT NIL :COMMENT "Split where one branch is impossible -- it should never
  556. try the possible branch for strategic reasons.
  557. Since the :max-transformation-depth is zero, we should
  558. propagate irrelevance after finding that we can't do any
  559. more work on the (isa ?X ?Y) literal wrt the inference.")
  560. ;;; Result(51)  <==== #<INFERENCE-UNIT-TEST 0>
  561. ;;; CYC(52): (DEFINE-INFERENCE-UNIT-TEST :FALSE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Thing #$Individual) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :EXPECTED-RESULT NIL :COMMENT "Like :impossible-strategic-split-stop except the easy branch
  562. is provably false instead of just impossible.")
  563. ;;; Result(52)  <==== #<INFERENCE-UNIT-TEST 0>
  564. ;;; CYC(53): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$Predicate) (#$and (#$isa ?PRED #$BinaryPredicate) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Like :impossible-strategic-split-stop except the easy branch is not provable,
  565. and its negation is not provable either.")
  566. ;;; Result(53)  <==== #<INFERENCE-UNIT-TEST 0>
  567. ;;; CYC(54): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-IMPOSSIBLE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X ?Y) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:CONTINUABLE? T :MAX-TIME 212)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Like :impossible-strategic-split-stop except the inference
  568. is not exhaustive, so it can't take any shortcuts in determining when
  569. it can prune the other branch of the split.")
  570. ;;; Result(54)  <==== #<INFERENCE-UNIT-TEST 0>
  571. ;;; CYC(55): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-CONTINUABLE-IMPOSSIBLE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X ?Y) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:CONTINUABLE? T :ALLOW-HL-PREDICATE-TRANSFORMATION? T :MAX-TIME 212)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Like :non-exhaustive-impossible-strategic-split-stop except that it
  572. really might be able to do some transformations upon continuation.
  573. Therefore, it would be incorrect to halt with :exhaust-total.")
  574. ;;; Result(55)  <==== #<INFERENCE-UNIT-TEST 0>
  575. ;;; CYC(56): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-FALSE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Thing #$Individual) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:CONTINUABLE? T :MAX-TIME 212)) :BINDINGS (QUOTE ((*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Like :false-strategic-split-stop except the inference
  576. is not exhaustive, so it can't take any shortcuts in determining when
  577. it can prune the other branch of the split.")
  578. ;;; Result(56)  <==== #<INFERENCE-UNIT-TEST 0>
  579. ;;; CYC(57): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-CONTINUABLE-FALSE-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Thing #$Individual) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:CONTINUABLE? T :ALLOW-HL-PREDICATE-TRANSFORMATION? T :MAX-TIME 212)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Like :non-exhaustive-false-strategic-split-stop except that it
  580. really might be able to do some transformations upon continuation.")
  581. ;;; Result(57)  <==== #<INFERENCE-UNIT-TEST 0>
  582. ;;; CYC(58): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-UNKNOWN-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$Predicate) (#$and (#$isa ?PRED #$BinaryPredicate) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TIME 212)) :BINDINGS (QUOTE ((*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Like :unknown-strategic-split-stop except the inference
  583. is not exhaustive, so it can't take any shortcuts in determining when
  584. it can prune the other branch of the split.")
  585. ;;; Result(58)  <==== #<INFERENCE-UNIT-TEST 0>
  586. ;;; CYC(59): (DEFINE-INFERENCE-UNIT-TEST :NON-EXHAUSTIVE-CONTINUABLE-UNKNOWN-STRATEGIC-SPLIT-STOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$Predicate) (#$and (#$isa ?PRED #$BinaryPredicate) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ALLOW-HL-PREDICATE-TRANSFORMATION? T :MAX-TIME 212)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Like :non-exhaustive-unknown-strategic-split-stop except that it
  587. really might be able to do some transformations upon continuation.")
  588. ;;; Result(59)  <==== #<INFERENCE-UNIT-TEST 0>
  589. ;;; CYC(60): (DEFINE-INFERENCE-UNIT-TEST :3-WAY-SPLIT-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$termChosen "a") (#$termChosen ?X) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "In a 3-way split, splits leading to cheap tactics (like termChosen)
  590. should be executed before more expensive tactics.")
  591. ;;; Result(60)  <==== #<INFERENCE-UNIT-TEST 0>
  592. ;;; CYC(61): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-CONTINUABLE-SPLIT-WITH-JOIN-ORDERED :OWNER "goolsbey" :BUG 11989 :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$equalSymbols ?A 1) (#$different ?A 2) (#$equalSymbols ?B 2) (#$different ?B 1)))) :PROPERTIES (QUOTE (:CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 2)))) :COMMENT "In bug 11989, the second split gets erroneously set-aside and never reconsidered.")
  593. ;;; Result(61)  <==== #<INFERENCE-UNIT-TEST 0>
  594. ;;; CYC(62): (DEFINE-INFERENCE-UNIT-TEST :3-WAY-SPLIT-WITH-VARIABLES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-A #$Collection) (#$isa ?A ?COL-A) (#$isa ?COL-B #$Collection) (#$isa ?B ?COL-B) (#$isa ?COL-C #$Collection) (#$isa ?C ?COL-C)) (#$and (#$isa ?X ?COL-A) (#$isa ?Y ?COL-B) (#$isa ?Z ?COL-C))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?A) (?Y . ?B) (?Z . ?C)))) :COMMENT "Three-way split with variables")
  595. ;;; Result(62)  <==== #<INFERENCE-UNIT-TEST 0>
  596. ;;; CYC(63): (DEFINE-INFERENCE-UNIT-TEST :TRICKY-3-WAY-SPLIT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$equalSymbols ?COL #$Collection) (#$evaluate ?NUM2 (#$PlusFn 1 211)) (#$evaluate ?NUM1 (#$TimesFn ?NUM2 2))))) :EXPECTED-RESULT (QUOTE (((?COL . #$Collection) (?NUM1 . 424) (?NUM2 . 212)))) :COMMENT "A tricky 3-way split that once found a bug in the split code")
  597. ;;; Result(63)  <==== #<INFERENCE-UNIT-TEST 0>
  598. ;;; CYC(64): (DEFINE-INFERENCE-UNIT-TEST :TRICKY-6-WAY-SPLIT :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa #$Individual ?COL) (#$isa #$Collection ?COL) (#$equalSymbols ?COL #$Collection) (#$isa ?NUM1 #$Thing) (#$evaluate ?NUM2 (#$PlusFn 1 211)) (#$evaluate ?NUM1 (#$TimesFn ?NUM2 2))))) :EXPECTED-RESULT (QUOTE (((?COL . #$Collection) (?NUM1 . 424) (?NUM2 . 212)))) :COMMENT "The 6-way split that the tricky 3-way split was distilled from.")
  599. ;;; Result(64)  <==== #<INFERENCE-UNIT-TEST 0>
  600. ;;; CYC(65): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-WITH-ALL-LITERALS-NOT-QUITE-CONNECTED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (?P "a" "b")) (#$thereExists ?C (#$thereExists ?D (#$and (?P ?A ?B) (#$elementOf ?C (#$TheSet 1 2 3 4 5 6 7 8 9 10)) (#$equalSymbols ?C ?D))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?A . "a") (?B . "b")))) :COMMENT "This case used to fool the code that tested whether a conjunctive
  601. problem should be solved via split or join, and used to cause a crash.
  602. The fix was to add the (singleton? connected-groups) clause in
  603. @xref all-literals-connected-by-shared-vars?")
  604. ;;; Result(65)  <==== #<INFERENCE-UNIT-TEST 0>
  605. ;;; CYC(66): (DEFINE-INFERENCE-UNIT-TEST :JOIN-NO-GOODNESS-PROPAGATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$elementOf ?X (#$TheSet 1)))) :PROPERTIES (QUOTE (:BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$elementOf ?X (#$TheSet 1)) (#$elementOf (?X 2) (#$TheSet (#$TheSet 1))))) :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT NIL) (:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (INFERENCE (FIND-INFERENCE-BY-ID STORE 1)) (PROBLEM (INFERENCE-ROOT-PROBLEM INFERENCE))) (TACTICALLY-NO-GOOD-PROBLEM-P PROBLEM))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Ensure that no-goodness propagates up a join
  606.    even if the other sibling conjunct problem is good.")
  607. ;;; Result(66)  <==== #<INFERENCE-UNIT-TEST 0>
  608. ;;; CYC(67): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-NO-GOODNESS-PROPAGATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf ?X (#$TheSet 1 2)) (#$elementOf ?X (#$TheSet 3 4 5))))) :PROPERTIES (QUOTE (:BROWSABLE? T :ALLOWED-MODULES (:NOT :JOIN) :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (PROBLEM (FIND-PROBLEM-BY-ID STORE 0))) (TACTICALLY-NO-GOOD-PROBLEM-P PROBLEM))))) :EXPECTED-RESULT (NIL)))) :COMMENT "When a conjunctive problem has executed a complete join-ordered
  609. tactic resulting in a finished focal problem
  610. and a non-focal problem all of whose restricted forms are no-good,
  611. the conjunctive problem should be deemed no-good.")
  612. ;;; Result(67)  <==== #<INFERENCE-UNIT-TEST 0>
  613. ;;; CYC(68): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-NO-GOODNESS-PROPAGATION :OWNER "pace" :BUG 10682 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg1Isa ?GENL-PRED ?COL-2) (#$isa ?TERM ?COL-1) (#$not (#$isa ?TERM ?COL-2)) (?SPEC-PRED ?TERM)) (#$ist #$InferencePSC (?GENL-PRED ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONTINUABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$InferencePSC (#$and (?GENL-PRED ?TERM) (?GENL-PRED "no"))) :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT NIL) (:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (PROBLEM (FIND-PROBLEM-BY-ID STORE 1))) (CAND (TACTICALLY-UNEXAMINED-PROBLEM-P PROBLEM) (TACTICALLY-NO-GOOD-PROBLEM-P PROBLEM)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "(1) The genlPreds proof for (?GENL-PRED ?TERM)
  614.    should be rejected due to intermediate step validation,
  615.    so this should create an unexamined-no-good problem.
  616.    (2) The followup introduces a split which leads to the
  617.    unexamined-no-good problem.  This triggers a crash
  618.    which is bug 10682.
  619.    (3) The last followup verifies that problem #1,
  620.    which ought to be the restricted form of the initial
  621.    query with the rejected proof, is indeed unexamined-no-good.")
  622. ;;; Result(68)  <==== #<INFERENCE-UNIT-TEST 0>
  623. ;;; CYC(69): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-NO-GOODNESS-PROPAGATION-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate)) (#$and (?PRED ?WHAT) (?CHAFF 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :TRANSFORMATION-ALLOWED? NIL :CONTINUABLE? T)) :BINDINGS (QUOTE ((*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CAND (TACTICALLY-NO-GOOD-PROBLEM-P (FIND-PROBLEM-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0)) (STRATEGICALLY-NO-GOOD-PROBLEM-P (FIND-PROBLEM-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0) (FIND-STRATEGY-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that this split is deemed tactically no-good.")
  624. ;;; Result(69)  <==== #<INFERENCE-UNIT-TEST 0>
  625. ;;; CYC(70): (DEFINE-INFERENCE-UNIT-TEST :3-WAY-UNION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$elementOf #$Collection (#$TheSet #$Thing)) (#$elementOf #$Collection (#$TheSet #$Individual)) (#$isa #$Collection #$Collection)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT ":union (independent #$or)")
  626. ;;; Result(70)  <==== #<INFERENCE-UNIT-TEST 0>
  627. ;;; CYC(71): (DEFINE-INFERENCE-UNIT-TEST :UNION-WITH-VARIABLES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$elementOf ?X (#$TheSet #$Collection)) (#$elementOf ?X (#$TheSet #$Individual))))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection)) ((?X . #$Individual)))) :COMMENT ":union that produces bindings")
  628. ;;; Result(71)  <==== #<INFERENCE-UNIT-TEST 0>
  629. ;;; CYC(72): (DEFINE-INFERENCE-UNIT-TEST :UNION-WITH-SCOPED-AND-UNSCOPED-VARIABLES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$elementOf ?X (#$TheSet #$Collection)) (#$and (#$thereExists ?Y (#$elementOf ?Y (#$TheSet #$TernaryPredicate))) (#$elementOf ?X (#$TheSet #$Individual)))))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection)) ((?X . #$Individual)))) :COMMENT "test whether the scoped variable ?Y doesn't interfere")
  630. ;;; Result(72)  <==== #<INFERENCE-UNIT-TEST 0>
  631. ;;; CYC(73): (DEFINE-INFERENCE-UNIT-TEST :UNION-WITH-DIFFERENT-SCOPED-VARIABLES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$thereExists ?Z (#$elementOf ?Z (#$TheSet #$TernaryPredicate))) (#$elementOf ?X (#$TheSet #$Collection))) (#$and (#$thereExists ?Y (#$elementOf ?Y (#$TheSet #$TernaryPredicate))) (#$elementOf ?X (#$TheSet #$Individual)))))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection)) ((?X . #$Individual)))) :COMMENT "test whether the scoped variables don't interfere")
  632. ;;; Result(73)  <==== #<INFERENCE-UNIT-TEST 0>
  633. ;;; CYC(74): (DEFINE-INFERENCE-UNIT-TEST :DISJUNCTION-FREE-EL-VARS-POLICY-REQUIRE-EQUAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$elementOf ?X (#$TheSet #$Individual))) (#$and (#$elementOf ?X (#$TheSet #$Thing)) (#$elementOf ?Y (#$TheSet #$Collection)))))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :REQUIRE-EQUAL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "This should be ill-formed when the policy for dealing
  634. with disjuncts' free EL variables is :require-equal")
  635. ;;; Result(74)  <==== #<INFERENCE-UNIT-TEST 0>
  636. ;;; CYC(75): (DEFINE-INFERENCE-UNIT-TEST :DISJUNCTION-FREE-EL-VARS-POLICY-COMPUTE-INTERSECTION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$elementOf ?X (#$TheSet #$Individual))) (#$and (#$elementOf ?X (#$TheSet #$Thing)) (#$elementOf ?Y (#$TheSet #$Collection)))))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (QUOTE (((?X . #$Individual)) ((?X . #$Thing)))) :COMMENT "This should return bindings for only ?X when the policy for dealing
  637. with disjuncts' free EL variables is :compute-intersection")
  638. ;;; Result(75)  <==== #<INFERENCE-UNIT-TEST 0>
  639. ;;; CYC(76): (DEFINE-INFERENCE-UNIT-TEST :DISJUNCTION-FREE-EL-VARS-POLICY-COMPUTE-UNION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$elementOf ?X (#$TheSet #$Individual))) (#$and (#$elementOf ?X (#$TheSet #$Thing)) (#$elementOf ?Y (#$TheSet #$Collection)))))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-UNION)) :EXPECTED-RESULT (QUOTE (((?X . #$Individual)) ((?X . #$Thing) (?Y . #$Collection)))) :COMMENT "This should return bindings for both ?X and ?Y when the policy for dealing
  640. with disjuncts' free EL variables is :compute-union")
  641. ;;; Result(76)  <==== #<INFERENCE-UNIT-TEST 0>
  642. ;;; CYC(77): (DEFINE-INFERENCE-UNIT-TEST :MINIMAL-COMPLETE-LINK-SET :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$equalSymbols ?A 1) (#$equalSymbols ?B 1)) (#$and (#$equalSymbols ?A 1) (#$and (#$equalSymbols ?B ?A) (#$equalSymbols 1 ?B)))))) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 1)))) :COMMENT "The minimal test case which uses at least one
  643. of each type of link")
  644. ;;; Result(77)  <==== #<INFERENCE-UNIT-TEST 0>
  645. ;;; CYC(78): (DEFINE-INFERENCE-UNIT-TEST :TWO-DIFFERENT-MTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT1 #$Microtheory) (#$ist ?MT1 (#$isa ?TERM1 #$Individual)) (#$isa ?MT2 #$Microtheory) (#$ist ?MT2 (#$isa ?TERM2 #$Individual))) (#$and (#$ist ?MT1 (#$isa ?TERM1 #$Individual)) (#$ist ?MT2 (#$isa ?TERM2 #$Individual)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Two different mts")
  646. ;;; Result(78)  <==== #<INFERENCE-UNIT-TEST 0>
  647. ;;; CYC(79): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?DOG #$Collection) (#$genls ?DOG #$Individual) (#$isa ?MUFFET ?DOG) (#$isa ?KEN #$Individual) (#$isa ?LOVES #$BinaryPredicate) (?LOVES ?MUFFET ?KEN)) (#$and (#$isa ?X ?DOG) (?LOVES ?X ?KEN))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?MUFFET)))) :COMMENT "simple :join-ordered")
  648. ;;; Result(79)  <==== #<INFERENCE-UNIT-TEST 0>
  649. ;;; CYC(80): (DEFINE-INFERENCE-UNIT-TEST :FAILING-JOIN-ORDERED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?DOG #$Collection) (#$genls ?DOG #$Individual) (#$isa ?MUFFET ?DOG) (#$isa ?KEN #$Individual)) (#$and (#$isa ?X ?DOG) (#$conceptuallyRelated ?X ?KEN))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT NIL :COMMENT ":join-ordered which should fail")
  650. ;;; Result(80)  <==== #<INFERENCE-UNIT-TEST 0>
  651. ;;; CYC(81): (DEFINE-INFERENCE-UNIT-TEST :LAZILY-MANIFEST-NON-FOCALS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?DOG #$Collection) (#$genls ?DOG #$Individual) (#$isa ?MUFFET ?DOG) (#$isa ?KEN #$Individual) (#$isa ?PRED #$UnaryPredicate)) (#$and (#$isa ?X ?DOG) (#$conceptuallyRelated ?X ?KEN) (?PRED ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :BROWSABLE? T)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (PLUSP (PROBLEM-STORE-UNMANIFESTED-NON-FOCAL-COUNT (CURRENTLY-ACTIVE-PROBLEM-STORE)))))) :PROPERTIES (:CONTINUABLE? NIL) :EXPECTED-RESULT (NIL)))) :COMMENT ":join-ordered which should fail, and should
  652. have some unmanifested non-focals")
  653. ;;; Result(81)  <==== #<INFERENCE-UNIT-TEST 0>
  654. ;;; CYC(82): (DEFINE-INFERENCE-UNIT-TEST :CHOOSE-RIGHT-JOIN-ORDERED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf ?X (#$TheSet #$Collection #$Individual)) (#$elementOf ?Y (#$TheSet #$Collection #$Individual)) (#$different ?X ?Y)))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection) (?Y . #$Individual)) ((?X . #$Individual) (?Y . #$Collection)))) :COMMENT "test to make sure it doesn't choose the #$different literal first.
  655. This also tests a lot of other stuff like variable mapping of bindings,
  656. problem reuse in conjunction with proof propagation, etc.")
  657. ;;; Result(82)  <==== #<INFERENCE-UNIT-TEST 0>
  658. ;;; CYC(83): (DEFINE-INFERENCE-UNIT-TEST :CHOOSE-RIGHT-JOIN-ORDERED-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf ?X (#$TheSet #$Collection #$Individual)) (#$elementOf ?Y (#$TheSet #$Cyclist #$Thing)) (#$different ?X ?Y)))) :EXPECTED-RESULT (QUOTE (((?X . #$Collection) (?Y . #$Cyclist)) ((?X . #$Collection) (?Y . #$Thing)) ((?X . #$Individual) (?Y . #$Cyclist)) ((?X . #$Individual) (?Y . #$Thing)))) :COMMENT "A more complex version of the previous one.  This one caught a bug
  659. in which we realized that a single problem lookahead was not enough
  660. and that we needed a lookahead queue instead.")
  661. ;;; Result(83)  <==== #<INFERENCE-UNIT-TEST 0>
  662. ;;; CYC(84): (DEFINE-INFERENCE-UNIT-TEST :FOCAL-BINDINGS-TO-NON-FOCAL-BINDINGS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$BinaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$isa ?C #$Individual) (#$isa ?D #$Individual) (?P ?A ?B) (?Q ?B ?C) (?Q ?B ?D)) (#$and (?P ?X ?Y) (?Q ?Y ?Z))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?A) (?Y . ?B) (?Z . ?C)) ((?X . ?A) (?Y . ?B) (?Z . ?D)))) :COMMENT "The key point here is the :join-ordered link between the two asked literals.
  663. It will try P first because it has only 1 extent instead of 2, then when
  664. it propagates the single proof of P, it has to translate those proof bindings
  665. from the P problem (the focal problem) into terms of the Q problem
  666. (the non-focal problem).  Since the Q literal only shares one of the variables
  667. with the P bindings, bad things will happen if the translation of the focal
  668. to non-focal bindings doesn't take into account which variables are shared.
  669. This was fixed by the call to compose-bindings-filtered in
  670. focal-bindings-to-non-focal-bindings.  If you change that to
  671. compose-bindings-unfiltered, this test will fail.")
  672. ;;; Result(84)  <==== #<INFERENCE-UNIT-TEST 0>
  673. ;;; CYC(85): (DEFINE-PROTECTED COMPOSE-BINDINGS-UNFILTERED (BINDINGS1 BINDINGS2 FILTER-LIST) "For showing exactly what the above test is testing" (IGNORE FILTER-LIST) (RET (RSUBLIS BINDINGS1 BINDINGS2)))
  674. ;;; Result(85)  <==== {CYC:COMPOSE-BINDINGS-UNFILTERED -SubLInterpretedFunction-}
  675. ;;; CYC(86): (DEFINE-INFERENCE-UNIT-TEST :CHOOSE-COMPLETE-JOIN-ORDERED-OVER-INCOMPLETE-JOIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$elementOf ?X (#$TheSet 212)) (#$quotedIsa ?X #$SubLInteger)))) :EXPECTED-RESULT (QUOTE (((?X . 212)))) :COMMENT "This makes sure that it prefers a complete
  676. join-ordered, even though more expensive,
  677. over an incomplete join.")
  678. ;;; Result(86)  <==== #<INFERENCE-UNIT-TEST 0>
  679. ;;; CYC(87): (DEFINE-INFERENCE-UNIT-TEST :INCOMPLETE-JOIN-BACKTRACKING :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?THING-COL #$Collection) (#$defnIff ?THING-COL (#$SubLQuoteFn TRUE))) (#$and (#$genls ?COL ?THING-COL) (#$isa ?COL ?THING-COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?COL . ?THING-COL)))) :COMMENT "This makes sure that even if it first tries
  680. to use a join link and fails because it can't
  681. enumerate all constants, it will then backtrack
  682. and try a join-ordered.")
  683. ;;; Result(87)  <==== #<INFERENCE-UNIT-TEST 0>
  684. ;;; CYC(88): (DEFINE-INFERENCE-UNIT-TEST :DONT-DO-A-POINTLESS-JOIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT #$Microtheory) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$ist ?MT (?P ?A)) (#$ist ?MT (?P ?B))) (#$ist ?MT (?Q ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist ?MT (#$and (?P ?WHAT) (?Q ?WHAT))) :PROPERTIES (:PRODUCTIVITY-LIMIT 212 :CONTINUABLE? T) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST) (:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (ZEROP (PROBLEM-STORE-TACTIC-OF-TYPE-WITH-STATUS-COUNT (CURRENTLY-ACTIVE-PROBLEM-STORE) :JOIN :EXECUTED))))) :PROPERTIES (:CONTINUABLE? NIL) :EXPECTED-RESULT (NIL)))) :COMMENT "Given a conjunction in which one of the problems is already pending (via problem store reuse)
  685. and has yielded no answers, there's no point in executing a join tactic which
  686. includes that problem.")
  687. ;;; Result(88)  <==== #<INFERENCE-UNIT-TEST 0>
  688. ;;; CYC(89): (DEFINE-INFERENCE-UNIT-TEST :INCOMPLETE-SHOULDNT-PRUNE-WHEN-TRANSFORMATION-NOT-ALLOWED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Integer) (#$defnIff ?COL (#$SubLQuoteFn INTEGERP))) (#$and (#$elementOf ?OBJ (#$TheSet "212" 212)) (#$isa ?OBJ ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :TRANSFORMATION-ALLOWED? NIL :MAX-TIME 10)) :EXPECTED-RESULT (QUOTE (((?OBJ . 212)))) :COMMENT "This test ensures that a cheap but incomplete tactic
  689.    doesn't cause the discarding of the other more complete tactics.")
  690. ;;; Result(89)  <==== #<INFERENCE-UNIT-TEST 0>
  691. ;;; CYC(90): (DEFINE-INFERENCE-UNIT-TEST :EXHAUST-TOTAL-BY-FIGURING-OUT-THAT-TRANSFORMATION-IS-IMPOSSIBLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Integer) (#$defnIff ?COL (#$SubLQuoteFn INTEGERP))) (#$and (#$elementOf ?OBJ (#$TheSet "212" 212)) (#$isa ?OBJ ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TIME 10)) :BINDINGS (QUOTE ((*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?OBJ . 212)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "This test verifies the ability of the Tactician to determine that
  692. transformation is really not possible because HL predicate transformation
  693. is forbidden.")
  694. ;;; Result(90)  <==== #<INFERENCE-UNIT-TEST 0>
  695. ;;; CYC(91): (DEFINE-INFERENCE-UNIT-TEST :INCOMPLETE-SHOULDNT-PRUNE-WHEN-TRANSFORMATION-ALLOWED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Integer) (#$defnIff ?COL (#$SubLQuoteFn INTEGERP))) (#$and (#$elementOf ?OBJ (#$TheSet "212" 212)) (#$isa ?OBJ ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ALLOW-HL-PREDICATE-TRANSFORMATION? T :MAX-TIME 10)) :EXPECTED-RESULT (QUOTE (((?OBJ . 212)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:MAX-TIME 1 :CONTINUABLE? NIL) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "This test ensures that a cheap but incomplete tactic
  696.    doesn't cause the discarding of the other more complete tactics.")
  697. ;;; Result(91)  <==== #<INFERENCE-UNIT-TEST 0>
  698. ;;; CYC(92): (PWHEN-FEATURE :CYC-QUANT (DEFINE-INFERENCE-UNIT-TEST :ONLY-POSSIBLE-TO-TRANSFORM-SHOULD-BE-INCOMPLETE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$isa (#$TheSet 212) ?COL) (#$implies (?P ?X) (#$extentCardinality ?X 1))) (#$and (#$extentCardinality ?X 1) (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :TRANSFORMATION-ALLOWED? T :ALLOW-HL-PREDICATE-TRANSFORMATION? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X #$TheSet 212)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:MAX-TIME 1 :CONTINUABLE? NIL) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "This test ensures that if a problem has no removal tactics
  699. but has transformation tactics, it's deemed incomplete rather
  700. than complete."))
  701. ;;; Result(92)  <==== #<INFERENCE-UNIT-TEST 0>
  702. ;;; CYC(93): (DEFINE-INFERENCE-UNIT-TEST :RESTRICTED-NON-FOCAL-TO-SUPPORTED-VARIABLE-MAP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED #$Individual) (?PRED #$Collection)) (#$and (#$elementOf ?X (#$TheSet #$Individual)) (#$elementOf ?Y (#$TheSet ?X)) (?PRED ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . #$Individual) (?Y . #$Individual)))) :COMMENT "This tests a bug which was found in
  703. @xref compute-restricted-non-focal-to-supported-variable-map
  704. in which the bindings were NIL instead of (?var0 . ?var1),
  705. because compose-bindings was being called instead of compose-bindings-filtered
  706. with the proper filter list.")
  707. ;;; Result(93)  <==== #<INFERENCE-UNIT-TEST 0>
  708. ;;; CYC(94): (DEFINE-INFERENCE-UNIT-TEST :CANONICALIZE-FOCAL-PROOF-BINDINGS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?STORK #$Collection) (#$isa ?STORK-1 ?STORK) (#$isa ?SEES #$BinaryPredicate) (#$isa ?KERMIT #$Individual) (?SEES ?STORK-1 ?KERMIT)) (#$and (#$isa ?S ?STORK) (#$isa ?F #$Individual) (?SEES ?S ?F))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?F . ?KERMIT) (?S . ?STORK-1)))) :COMMENT "This tests for a bug in the focal proof index code.
  709. If the bindings are not canonicalized before adding to the index
  710. and before looking up from the index, sometimes the lookup will
  711. fail when it should succeed.  This was originally found by the
  712. :two-step :forward inference test failing.")
  713. ;;; Result(94)  <==== #<INFERENCE-UNIT-TEST 0>
  714. ;;; CYC(95): (DEFINE-INFERENCE-UNIT-TEST :SIMPLIFY-UNIFICATION-BINDINGS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED (#$TheSetOf ?OBJ (#$equalSymbols ?OBJ 212)))) (#$thereExists ?SENTENCE (#$and (#$equalSymbols ?OBJ 212) (?PRED (#$TheSetOf ?OBJ ?SENTENCE))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?OBJ . 212)))) :COMMENT "This tests that the scoped variable ?OBJ in the consequent of this ask gets properly
  715.   renamed, and that the renamed variable gets properly unified with the ?OBJ in the
  716.   antecedent, and that this uninteresting unification binding is simplified away.")
  717. ;;; Result(95)  <==== #<INFERENCE-UNIT-TEST 0>
  718. ;;; CYC(96): (DEFINE-INFERENCE-UNIT-TEST :SIMPLIFY-UNIFICATION-BINDINGS-THECOLLECTIONOF :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED (#$TheCollectionOf ?OBJ (#$equalSymbols ?OBJ 212)))) (#$thereExists ?SENTENCE (#$and (#$equalSymbols ?OBJ 212) (?PRED (#$TheCollectionOf ?OBJ ?SENTENCE))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?OBJ . 212)))) :COMMENT "This tests that TheCollectionOf works like TheSetOf.  Just like
  719.    :simplify-unification-bindings except with TheCollectionOf.")
  720. ;;; Result(96)  <==== #<INFERENCE-UNIT-TEST 0>
  721. ;;; CYC(97): (DEFINE-INFERENCE-UNIT-TEST :DONT-PROPAGATE-BEFORE-VARIABLE-MAP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$equalSymbols ?X #$Thing) (#$equalSymbols ?Y ?X)))) :EXPECTED-RESULT (QUOTE (((?X . #$Thing) (?Y . #$Thing)))) :COMMENT "Test to make sure it returns bindings for ?Y as well as ?X.
  722. This was failing because a split-restriction link was being
  723. propagated before its variable map was added.  The fix was to
  724. make sure this was done in the right order.")
  725. ;;; Result(97)  <==== #<INFERENCE-UNIT-TEST 0>
  726. ;;; CYC(98): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-INTERPRETATIONS-OF-SAME-SUPPORTING-PROBLEM :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$equalSymbols ?Z #$Thing) (#$elementOf ?X (#$TheSet ?Z)) (#$elementOf ?Y (#$TheSet ?Z))))) :EXPECTED-RESULT (QUOTE (((?X . #$Thing) (?Y . #$Thing) (?Z . #$Thing)))) :COMMENT "Test for a variable map index with two #'eq problems but
  727. different variable maps.")
  728. ;;; Result(98)  <==== #<INFERENCE-UNIT-TEST 0>
  729. ;;; CYC(99): (DEFINE-INFERENCE-UNIT-TEST :INTERMEDIATE-STEP-VALIDATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?UNARY-PRED #$UnaryPredicate) (#$isa ?BINARY-PRED #$BinaryPredicate) (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$arg1Isa ?BINARY-PRED ?COL-1) (#$arg2Isa ?BINARY-PRED ?COL-1) (#$disjointWith ?COL-1 ?COL-2) (?BINARY-PRED #$Individual #$Collection) (?BINARY-PRED #$Collection #$Individual) (#$relationAllExists ?BINARY-PRED ?COL-1 ?COL-2) (#$isa ?INS-1 ?COL-1) (?UNARY-PRED ?INS-1) (?BINARY-PRED ?INS-1 ?INS-1)) (#$and (?UNARY-PRED ?X) (?BINARY-PRED ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT (QUOTE (((?X . ?INS-1) (?Y . ?INS-1)))) :COMMENT "Test to see that it filters out the potential binding of
  730. the RelationAllExistsFn nat for ?Y because it is an instance of ?COL-2
  731. which is disjoint from ?COL-1, the arg2Isa of ?BINARY-PRED.")
  732. ;;; Result(99)  <==== #<INFERENCE-UNIT-TEST 0>
  733. ;;; CYC(100): (DEFINE-INFERENCE-UNIT-TEST :NO-INTERMEDIATE-STEP-VALIDATION :OWNER "goolsbey" :BUG 4310 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?UNARY-PRED #$UnaryPredicate) (#$isa ?BINARY-PRED #$BinaryPredicate) (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$arg1Isa ?BINARY-PRED ?COL-1) (#$arg2Isa ?BINARY-PRED ?COL-1) (#$disjointWith ?COL-1 ?COL-2) (?BINARY-PRED #$Individual #$Collection) (?BINARY-PRED #$Collection #$Individual) (#$relationAllExists ?BINARY-PRED ?COL-1 ?COL-2) (#$isa ?INS-1 ?COL-1) (?UNARY-PRED ?INS-1) (?BINARY-PRED ?INS-1 ?INS-1)) (#$and (?UNARY-PRED ?X) (?BINARY-PRED ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?X . ?INS-1) (?Y . ?INS-1)) ((?X . ?INS-1) (?Y #$RelationAllExistsFn ?INS-1 ?BINARY-PRED ?COL-1 ?COL-2)))) :COMMENT "The dual of @xref :intermediate-step-validation, which differs only in that
  734. the :intermediate-step-validation-level is :none and it does not filter out the ill-formed binding.")
  735. ;;; Result(100)  <==== #<INFERENCE-UNIT-TEST 0>
  736. ;;; CYC(101): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-EXISTENTIAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$thereExists ?X (#$elementOf ?X (#$TheSet #$TernaryPredicate))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that an existential inhibits returned bindings")
  737. ;;; Result(101)  <==== #<INFERENCE-UNIT-TEST 0>
  738. ;;; CYC(102): (DEFINE-INFERENCE-UNIT-TEST :TWO-VARIABLE-EXISTENTIAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?DOG #$Collection) (#$isa ?MUFFET ?DOG)) (#$and (#$thereExists ?X (#$and (#$elementOf ?X (#$TheSet #$TernaryPredicate)) (#$isa ?Y ?DOG))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?Y . ?MUFFET)))) :COMMENT "Test that an existential inhibits some of the returned bindings
  739. but not all of them")
  740. ;;; Result(102)  <==== #<INFERENCE-UNIT-TEST 0>
  741. ;;; CYC(103): (DEFINE-INFERENCE-UNIT-TEST :NON-HLMT-TACTICS :OWNER "kknight" :CREATOR "hagen" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$ist ?MT (#$isa #$Thing #$Thing)) (#$elementOf ?MT (#$TheSet #$BaseKB #$UniversalVocabularyMt))))) :EXPECTED-RESULT (QUOTE (((?MT . #$BaseKB)) ((?MT . #$UniversalVocabularyMt)))) :COMMENT "Test that it does not crash on non-HLMT tactics,
  742. e.g. a contextualized literal with a variable mt
  743. It should deem two of the three connected conjunction
  744. tactics impossible, and try the one that does the
  745. elementOf first.")
  746. ;;; Result(103)  <==== #<INFERENCE-UNIT-TEST 0>
  747. ;;; CYC(104): (DEFINE-INFERENCE-UNIT-TEST :DO-CONJUNCTS-BEFORE-CONJUNCTION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$quotedIsa "test" #$SubLInteger) (#$and (#$elementOf ?TERM (#$TheSet 1 2 3)) (#$performSubL (#$ExpandSubLFn (?TERM) (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test to make sure it fails on the first conjunct before trying to
  748. evaluate the more expensive second one.")
  749. ;;; Result(104)  <==== #<INFERENCE-UNIT-TEST 0>
  750. ;;; CYC(105): (DEFINE-INFERENCE-UNIT-TEST :DO-CONJUNCTS-BEFORE-CONJUNCTION-PROVE-NEGATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$quotedIsa "test" #$SubLInteger) (#$and (#$elementOf ?TERM (#$TheSet 1 2 3)) (#$performSubL (#$ExpandSubLFn (?TERM) (QUERY-ABORT))))))) :EXPECTED-RESULT NIL :COMMENT "Test to make sure it fails on the first conjunct before trying to
  751. evaluate the more expensive second one.  For this test, unlike
  752. :do-conjuncts-before-conjunction, it has to prove the negation
  753. of (isa 'test' Integer) in order to deem that problem no-good,
  754. because it still has possible transformation tactics so it can't
  755. deem it no-good by tactical completeness.")
  756. ;;; Result(105)  <==== #<INFERENCE-UNIT-TEST 0>
  757. ;;; CYC(106): (DEFINE-INFERENCE-UNIT-TEST :INFERENCE-ABORT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$performSubL (#$SubLQuoteFn (PROGN (MAKE-PROCESS-WITH-ARGS "Assassin" (QUOTE INFERENCE-ABORT) (LIST (CURRENT-CONTROLLING-INFERENCE))) (PROCESS-BLOCK)))))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-HALT-REASON :ABORT :COMMENT "Test to make sure that another thread can forcibly abort a running inference.")
  758. ;;; Result(106)  <==== #<INFERENCE-UNIT-TEST 0>
  759. ;;; CYC(107): (DEFINE-INFERENCE-UNIT-TEST :ABORT-CURRENT-CONTROLLING-INFERENCE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$performSubL (#$SubLQuoteFn (PROGN (QUERY-ABORT) (SLEEP 1)))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ABORT :COMMENT "Test that (query-abort) works.")
  760. ;;; Result(107)  <==== #<INFERENCE-UNIT-TEST 0>
  761. ;;; CYC(108): (DEFINE-INFERENCE-UNIT-TEST :INSTANTANEOUS-ABORT-CURRENT-CONTROLLING-INFERENCE :OWNER "goolsbey" :BUG 8166 :SENTENCE (QUOTE (#$ist #$BaseKB (#$performSubL (#$SubLQuoteFn (QUERY-ABORT))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ABORT :COMMENT "Test that aborting yields a halt-reason of :abort,
  762. even if the inference finishes before the other process
  763. yields a timeslice.  There's no need to spawn another
  764. process if you're aborting yourself.")
  765. ;;; Result(108)  <==== #<INFERENCE-UNIT-TEST 0>
  766. ;;; CYC(109): (DEFINE-INFERENCE-UNIT-TEST :INFERENCE-INTERRUPT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$evaluate ?N (#$EvaluateSubLFn (#$SubLQuoteFn (PROGN (MAKE-PROCESS-WITH-ARGS "Interruptor" (QUOTE INFERENCE-INTERRUPT) (LIST (CURRENT-CONTROLLING-INFERENCE) 10)) (SLEEP 1) 2)))) (#$performSubL (#$ExpandSubLFn (?N) (SLEEP ?N)))))) :PROPERTIES (QUOTE (:MAX-TIME 10)) :EXPECTED-HALT-REASON :INTERRUPT :COMMENT "Test to make sure that another thread can cleanly interrupt a running inference during the evaluation of a tactic.")
  767. ;;; Result(109)  <==== #<INFERENCE-UNIT-TEST 0>
  768. ;;; CYC(110): (DEFINE-PRIVATE INFERENCE-DELAYED-INTERRUPT-TEST-FUNCTION (INFERENCE) (SLEEP 1) (RET (INFERENCE-INTERRUPT INFERENCE 10)))
  769. ;;; Result(110)  <==== {CYC:INFERENCE-DELAYED-INTERRUPT-TEST-FUNCTION -SubLInterpretedFunction-}
  770. ;;; CYC(111): (DEFINE-INFERENCE-UNIT-TEST :INFERENCE-DELAYED-INTERRUPT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$evaluate ?N (#$EvaluateSubLFn (#$SubLQuoteFn (PROGN (MAKE-PROCESS-WITH-ARGS "Interruptor" (QUOTE INFERENCE-DELAYED-INTERRUPT-TEST-FUNCTION) (LIST (CURRENT-CONTROLLING-INFERENCE))) 2)))) (#$performSubL (#$ExpandSubLFn (?N) (SLEEP ?N))) (#$performSubL (#$ExpandSubLFn (?N) (SLEEP (+ 0 ?N))))))) :PROPERTIES (QUOTE (:MAX-TIME 10)) :EXPECTED-HALT-REASON :INTERRUPT :COMMENT "Test to make sure that another thread can cleanly interrupt a running inference between tactics.")
  771. ;;; Result(111)  <==== #<INFERENCE-UNIT-TEST 0>
  772. ;;; CYC(112): (DEFINE-INFERENCE-UNIT-TEST :MAX-TIME-OBEYED-WHEN-NON-CONTINUABLE :OWNER "goolsbey" :BUG 5912 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$performSubL (#$SubLQuoteFn (SLEEP 2))))) :PROPERTIES (QUOTE (:MAX-TIME 1 :CONTINUABLE? NIL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :MAX-TIME :COMMENT "Test that ensures :MAX-TIME is obeyed for a non-continuable inference.")
  773. ;;; Result(112)  <==== #<INFERENCE-UNIT-TEST 0>
  774. ;;; CYC(113): (DEFINE-INFERENCE-UNIT-TEST :MAX-TIME-OBEYED-WHEN-CONTINUABLE :OWNER "goolsbey" :WORKING? NIL :BUG 5779 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$performSubL (#$SubLQuoteFn (SLEEP 2))))) :PROPERTIES (QUOTE (:MAX-TIME 1 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :MAX-TIME :COMMENT "Test that ensures :MAX-TIME is obeyed for a continuable inference.")
  775. ;;; Result(113)  <==== #<INFERENCE-UNIT-TEST 0>
  776. ;;; CYC(114): (DEFINE-INFERENCE-UNIT-TEST :MAX-STEP-OBEYED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$elementOf ?X (#$TheSet 1 2)))) :PROPERTIES (QUOTE (:MAX-STEP 4)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-STEP :COMMENT "Test that ensures :MAX-STEP is obeyed.")
  777. ;;; Result(114)  <==== #<INFERENCE-UNIT-TEST 0>
  778. ;;; CYC(115): (DEFINE-INFERENCE-UNIT-TEST :MAX-NUMBER-OBEYED-WHEN-CONTINUABLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$elementOf ?X (#$TheSet 1 2)))) :PROPERTIES (QUOTE (:MAX-NUMBER 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Test that ensures :MAX-NUMBER is obeyed for a continuable inference.")
  779. ;;; Result(115)  <==== #<INFERENCE-UNIT-TEST 0>
  780. ;;; CYC(116): (DEFINE-INFERENCE-UNIT-TEST :MAX-PROOF-DEPTH-OBEYED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$or (#$equalSymbols ?A 1) (#$and (#$elementOf ?A (#$TheSet 1 2)) (#$different ?A 212))))) :PROPERTIES (QUOTE (:MAX-PROOF-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . 1)))) :COMMENT "Test that it doesn't work on problems with a proof depth greater than the :max-proof-depth.")
  781. ;;; Result(116)  <==== #<INFERENCE-UNIT-TEST 0>
  782. ;;; CYC(117): (DEFINE-INFERENCE-UNIT-TEST :MAX-PROOF-DEPTH-OBEYED-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$isa #$Thing ?THING) (#$isa ?THING #$Thing) (#$equalSymbols ?THING #$Thing)))) :PROPERTIES (QUOTE (:MAX-PROOF-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Testing the same thing as :max-proof-depth-obeyed, but this one has the exact
  783. same query as :czer-merges-duplicate-literals so they make a minimal pair.")
  784. ;;; Result(117)  <==== #<INFERENCE-UNIT-TEST 0>
  785. ;;; CYC(118): (DEFINE-INFERENCE-UNIT-TEST :DONT-ASSUME-HERBRAND-MODEL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?COL #$Collection) (#$not (#$isa #$Thing ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "#$Thing is neither known to be an instance
  786. of ?COL nor known to be disjoint with it.
  787. This should be proven iff :negation-by-failure?
  788. is enabled.")
  789. ;;; Result(118)  <==== #<INFERENCE-UNIT-TEST 0>
  790. ;;; CYC(119): (DEFINE-INFERENCE-UNIT-TEST :ASSUME-HERBRAND-MODEL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?COL #$Collection) (#$not (#$isa #$Thing ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :NEGATION-BY-FAILURE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test whether the :negation-by-failure? property is obeyed.
  791. #$Thing is neither known to be an instance
  792. of ?COL nor known to be disjoint with it.
  793. This should be proven iff :negation-by-failure?
  794. is enabled.")
  795. ;;; Result(119)  <==== #<INFERENCE-UNIT-TEST 0>
  796. ;;; CYC(120): (DEFINE-INFERENCE-UNIT-TEST :DONT-MINIMIZE-EXTENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Thing) (#$isa ?TERM-2 #$Thing) (#$minimizeExtent ?PRED)) (#$not (?PRED ?TERM-1 ?TERM-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :NEGATION-BY-FAILURE? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that the :minimize extent module does not run when
  797.    :negation-by-failure? is nil.")
  798. ;;; Result(120)  <==== #<INFERENCE-UNIT-TEST 0>
  799. ;;; CYC(121): (DEFINE-INFERENCE-UNIT-TEST :MINIMIZE-EXTENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Thing) (#$isa ?TERM-2 #$Thing) (#$minimizeExtent ?PRED)) (#$not (?PRED ?TERM-1 ?TERM-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :NEGATION-BY-FAILURE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the :minimize extent module does run when
  800.    :negation-by-failure? is T.")
  801. ;;; Result(121)  <==== #<INFERENCE-UNIT-TEST 0>
  802. ;;; CYC(122): (DEFINE-INFERENCE-UNIT-TEST :COMPLETENESS-MINIMIZATION-ALLOWED?-OBEYED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Thing) (#$completelyEnumerableCollection ?COL) (#$isa ?TERM #$Thing)) (#$not (#$isa ?TERM ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :COMPLETENESS-MINIMIZATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove negations based on completeness information
  803. when :completeness-minimization-allowed? is NIL.")
  804. ;;; Result(122)  <==== #<INFERENCE-UNIT-TEST 0>
  805. ;;; CYC(123): (DEFINE-INFERENCE-UNIT-TEST :CZER-MERGES-DUPLICATE-LITERALS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$isa #$Thing ?THING) (#$isa ?THING #$Thing) (#$equalSymbols ?THING #$Thing)))) :PROPERTIES (QUOTE (:MAX-PROOF-DEPTH 2)) :EXPECTED-RESULT (QUOTE (((?THING . #$Thing)))) :COMMENT "Test that the problem-query canonicalizer merges duplicate literals
  806. during intermediate steps of inference.  It should merge the two #$isa
  807. literals as soon as ?THING gets bound to #$Thing.")
  808. ;;; Result(123)  <==== #<INFERENCE-UNIT-TEST 0>
  809. ;;; CYC(124): (DEFINE-INFERENCE-UNIT-TEST :DISALLOWED-MODULES-DONT-CONTRIBUTE-TO-LOOKAHEAD-PRODUCTIVITY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$UnaryPredicate) (#$and (#$arg1Isa ?PRED ?COL) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :REMOVAL-RELATION-ALL-INSTANCE-UNIFY))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "The abort trap should be avoided by determining that the
  810.    #$isa literal is cheaper, since the additional module that
  811.    would make it more expensive is not allowed, and therefore
  812.    should not factor into productivity considerations.")
  813. ;;; Result(124)  <==== #<INFERENCE-UNIT-TEST 0>
  814. ;;; CYC(125): (DEFINE-INFERENCE-UNIT-TEST :ALLOWED-MODULES-DO-CONTRIBUTE-TO-LOOKAHEAD-PRODUCTIVITY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PRED #$UnaryPredicate) (#$and (#$arg1Isa ?PRED ?COL) (#$evaluate ?ABORT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ABORT :COMMENT "The dual of :disallowed-modules-dont-contribute-to-lookahead-productivity.
  815. Exactly the same except for the :allowed-modules and the expected halt reason.")
  816. ;;; Result(125)  <==== #<INFERENCE-UNIT-TEST 0>
  817. ;;; CYC(126): (DEFINE-INFERENCE-UNIT-TEST :USE-INDETERMINATE-RESULT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$relationAllExists ?PRED ?COL #$Individual) (#$isa ?TERM ?COL)) (#$thereExists ?VALUE (?PRED ?TERM ?VALUE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? NIL :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that :allow-indeterminate-results? nil will not filter an #$IndeterminateTerm binding
  818. that is explicitly scoped so that it won't appear as a top-level result.")
  819. ;;; Result(126)  <==== #<INFERENCE-UNIT-TEST 0>
  820. ;;; CYC(127): (DEFINE-INFERENCE-UNIT-TEST :ALLOW-INDETERMINATE-RESULT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$relationAllExists ?PRED ?COL #$Individual) (#$isa ?TERM ?COL)) (?PRED ?TERM ?VALUE)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?VALUE #$RelationAllExistsFn ?TERM ?PRED ?COL #$Individual)))) :COMMENT "Verify that :allow-indeterminate-results? t will include the #$IndeterminateTerm binding.")
  821. ;;; Result(127)  <==== #<INFERENCE-UNIT-TEST 0>
  822. ;;; CYC(128): (DEFINE-INFERENCE-UNIT-TEST :FILTER-INDETERMINATE-RESULT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$relationAllExists ?PRED ?COL #$Individual) (#$isa ?TERM ?COL)) (?PRED ?TERM ?VALUE)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? NIL :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT NIL :COMMENT "Verify that :allow-indeterminate-results? nil will filter the #$IndeterminateTerm binding.")
  823. ;;; Result(128)  <==== #<INFERENCE-UNIT-TEST 0>
  824. ;;; CYC(129): (DEFINE-INFERENCE-UNIT-TEST :TEMPLATE-RETURN-TYPE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$equalSymbols ?WHAT 212))) :PROPERTIES (QUOTE (:RETURN (:TEMPLATE (("The number is" ?WHAT))))) :EXPECTED-RESULT-TEST (QUOTE EQUAL) :EXPECTED-RESULT (QUOTE ((("The number is" 212)))) :COMMENT "Test that it correctly handles the :template return type.")
  825. ;;; Result(129)  <==== #<INFERENCE-UNIT-TEST 0>
  826. ;;; CYC(130): (DEFINE-INFERENCE-UNIT-TEST :CANONICALIZE-INFERENCE-ANSWER-JUSTIFICATIONS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DEFN-COL #$Collection) (#$genls ?DEFN-COL #$Integer) (#$defnIff ?DEFN-COL (#$SubLQuoteFn CYC-NEGATIVE-INTEGER))) (#$and (#$elementOf ?A (#$TheSet -1 0 1)) (#$elementOf ?B (#$TheSet -1 0 1)) (#$evaluate ?PROD (#$TimesFn ?A ?B)) (#$isa ?PROD ?DEFN-COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-SUPPORTS :ANSWER-LANGUAGE :HL :MAX-TIME 10)) :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-RESULT 2 :COMMENT "Test that inference answer justifications have their
  827.    supports canonicalized, and therefore do not have
  828.    uninteresting duplications based only on support ordering.")
  829. ;;; Result(130)  <==== #<INFERENCE-UNIT-TEST 0>
  830. ;;; CYC(131): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-PARADOX :OWNER "pace" :BUG 2448 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-SET (#$and (#$equalSymbols ?RUSSELL-SET (#$TheSetOf ?X (#$not (#$elementOf ?X ?X)))) (#$elementOf ?RUSSELL-SET ?RUSSELL-SET))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 10)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON NIL :COMMENT "Test 1 of 2 that Cyc is agnostic about the truth of the Russell Paradox.")
  831. ;;; Result(131)  <==== #<INFERENCE-UNIT-TEST 0>
  832. ;;; CYC(132): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-PARADOX-NEGATED :OWNER "pace" :BUG 2448 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-SET (#$and (#$equalSymbols ?RUSSELL-SET (#$TheSetOf ?X (#$not (#$elementOf ?X ?X)))) (#$not (#$elementOf ?RUSSELL-SET ?RUSSELL-SET)))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 10)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON NIL :COMMENT "Test 2 of 2 that Cyc is agnostic about the truth of the Russell Paradox.")
  833. ;;; Result(132)  <==== #<INFERENCE-UNIT-TEST 0>
  834. ;;; CYC(133): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-COLLECTION-PARADOX :OWNER "pace" :BUG 2448 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-COL (#$and (#$equalSymbols ?RUSSELL-COL (#$TheCollectionOf ?X (#$not (#$isa ?X ?X)))) (#$isa ?RUSSELL-COL ?RUSSELL-COL))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 10)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON NIL :COMMENT "Test 1 of 2 that Cyc is agnostic about the truth of the collection version of the Russell Paradox.")
  835. ;;; Result(133)  <==== #<INFERENCE-UNIT-TEST 0>
  836. ;;; CYC(134): (DEFINE-INFERENCE-UNIT-TEST :RUSSELL-COLLECTION-PARADOX-NEGATED :OWNER "pace" :BUG 2448 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?RUSSELL-COL (#$and (#$equalSymbols ?RUSSELL-COL (#$TheCollectionOf ?X (#$not (#$isa ?X ?X)))) (#$not (#$isa ?RUSSELL-COL ?RUSSELL-COL)))))) :PROPERTIES (QUOTE (:CONTINUABLE? NIL :MAX-TIME 10)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON NIL :COMMENT "Test 2 of 2 that Cyc is agnostic about the truth of the collection version of the Russell Paradox.")
  837. ;;; Result(134)  <==== #<INFERENCE-UNIT-TEST 0>
  838. ;;; CYC(135): (DEFINE-INFERENCE-UNIT-TEST :NON-EXPLANATORY-SENTENCE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$elementOf ?NUM (#$TheSet 212 213)))) :PROPERTIES (QUOTE (:NON-EXPLANATORY-SENTENCE (#$ist #$UniversalVocabularyMt (#$equalSymbols ?NUM 212)) :ANSWER-LANGUAGE :HL)) :EXPECTED-RESULT (QUOTE (((?NUM . 212)))) :COMMENT "Test that ensures that :non-explanatory-sentence properly restricts inference.")
  839. ;;; Result(135)  <==== #<INFERENCE-UNIT-TEST 0>
  840. ;;; CYC(136): (DEFINE-INFERENCE-UNIT-TEST :NON-EXPLANATORY-SENTENCE-SUPPORTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$elementOf ?NUM (#$TheSet 212 213)))) :PROPERTIES (QUOTE (:NON-EXPLANATORY-SENTENCE (#$ist #$UniversalVocabularyMt (#$equalSymbols ?NUM 212)) :RETURN :SUPPORTS :ANSWER-LANGUAGE :HL)) :EXPECTED-RESULT-TEST (QUOTE TREE-MATCHES-PATTERN) :EXPECTED-RESULT (QUOTE ((:ANYTHING))) :COMMENT "Test that ensures that the non-explanatory supports are not included in justifications
  841.    when there is a :non-explanatory-sentence.")
  842. ;;; Result(136)  <==== #<INFERENCE-UNIT-TEST 0>
  843. ;;; CYC(137): (DEFINE-INFERENCE-UNIT-TEST :NON-EXPLANATORY-VARIABLE-MAP-SUPPORTS :OWNER "goolsbey" :BUG 7245 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$evaluate ?TWO (#$PlusFn ?ONE ?ONE)))) :PROPERTIES (QUOTE (:NON-EXPLANATORY-SENTENCE (#$equalSymbols ?ONE 1) :RETURN :SUPPORTS :ANSWER-LANGUAGE :HL)) :EXPECTED-RESULT-TEST (QUOTE TREE-MATCHES-PATTERN) :EXPECTED-RESULT (QUOTE ((:ANYTHING))) :COMMENT "Test that ensures that the explanatory supports are included in justifications
  844.    when there is a :non-explanatory-sentence that is the focal problem.")
  845. ;;; Result(137)  <==== #<INFERENCE-UNIT-TEST 0>
  846. ;;; CYC(138): (DEFINE-INFERENCE-UNIT-TEST :EL-RESULTS :OWNER "goolsbey" :BUG 4312 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED (#$PerFn #$Unity #$Unity))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT #$PerFn #$Unity #$Unity)))) :COMMENT "Test that EL results are returned by default, so we should
  847. get a naut rather than a nart.")
  848. ;;; Result(138)  <==== #<INFERENCE-UNIT-TEST 0>
  849. ;;; CYC(139): (DEFINE-INFERENCE-UNIT-TEST :CONNECTED-CONJUNCTION-BACKTRACKING :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?CYCLIST #$Collection) (#$isa ?LOGIC #$Individual) (#$isa ?FIELDS-OF-COMPETENCE #$BinaryPredicate) (#$relationAllInstance ?FIELDS-OF-COMPETENCE ?CYCLIST ?LOGIC) (#$isa ?FAMILY-NAME #$BinaryPredicate) (#$isa ?FOXVOG ?CYCLIST) (?FAMILY-NAME ?FOXVOG "foxvog") (?FAMILY-NAME #$Thing "Mr. Thing") (?FAMILY-NAME #$Collection "Mr. Collection") (#$isa ?MING ?CYCLIST) (?FIELDS-OF-COMPETENCE ?MING ?LOGIC)) (#$and (?FAMILY-NAME ?WHO "foxvog") (?FIELDS-OF-COMPETENCE ?WHO ?LOGIC))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHO . ?FOXVOG)))) :COMMENT "This now succeeds due to :removal-relation-all-instance-iterate.")
  850. ;;; Result(139)  <==== #<INFERENCE-UNIT-TEST 0>
  851. ;;; CYC(140): (DEFINE-INFERENCE-UNIT-TEST :PROOF-DEPTH-EXTENSION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?A (#$thereExists ?B (#$and (#$equalSymbols ?A 212) (#$equalSymbols ?B 212) (#$equals ?A ?B)))))) :PROPERTIES (QUOTE (:CONTINUABLE? T :MAX-PROOF-DEPTH 2)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? NIL :MAX-PROOF-DEPTH 3) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to ensure that continuation with increasing values for :max-proof-depth
  852.    causes proper reconsideration of set-aside problems.")
  853. ;;; Result(140)  <==== #<INFERENCE-UNIT-TEST 0>
  854. ;;; CYC(141): (DEFINE-INFERENCE-UNIT-TEST :PRODUCTIVITY-LIMIT-EXTENSION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$elementOf ?X (#$TheSet 212)))) :PROPERTIES (QUOTE (:CONTINUABLE? T :PRODUCTIVITY-LIMIT 99)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? NIL :PRODUCTIVITY-LIMIT 101) :EXPECTED-RESULT (((?X . 212))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to ensure that continuation with increasing values for :productivity-limit
  855.    causes proper reconsideration of set-aside problems.")
  856. ;;; Result(141)  <==== #<INFERENCE-UNIT-TEST 0>
  857. ;;; CYC(142): (DEFINE-INFERENCE-UNIT-TEST :GOOD-PROBLEMS-ARE-NOT-IMPOSSIBLE :OWNER "goolsbey" :BUG 16021 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED 5)) (#$and (?PRED ?X) (#$integerBetween 1 ?X 5) (#$performSubL (#$ExpandSubLFn (?X) (PWHEN (= ?X 1) (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :PREVIOUS :EXPECTED-RESULT (((?X . 5))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "The first time the query is asked it should correctly focus on (?PRED ?X).
  858.    When the followup query is asked, it should not deem (?PRED ?X) impossible
  859.    simply because it is already pending.")
  860. ;;; Result(142)  <==== #<INFERENCE-UNIT-TEST 0>
  861. ;;; CYC(143): (DEFINE-INFERENCE-UNIT-TEST :GOOD-PROBLEMS-ARE-NOT-IMPOSSIBLE-2 :OWNER "goolsbey" :BUG 16021 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED 5)) (#$and (?PRED ?X) (#$integerBetween 1 ?X 5) (#$performSubL (#$ExpandSubLFn (?X) (PWHEN (= ?X 1) (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :PREVIOUS :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT (((?X . 5))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL) (:SENTENCE :PREVIOUS :EXPECTED-RESULT (((?X . 5))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Like :good-problems-are-not-impossible, except asks two followups instead of just one.")
  862. ;;; Result(143)  <==== #<INFERENCE-UNIT-TEST 0>
  863. ;;; CYC(144): (DEFINE-INFERENCE-UNIT-TEST :NEUTRAL-PROBLEMS-ARE-NOT-IMPOSSIBLE :OWNER "goolsbey" :BUG 16021 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (?PRED 5 6)) (#$and (?PRED ?X ?X) (#$integerBetween 1 ?X 5) (#$performSubL (#$ExpandSubLFn (?X) (PWHEN (= ?X 1) (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :PREVIOUS :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "The first time the query is asked it should correctly focus on (?PRED ?X ?X).
  864.    When the followup query is asked, it should not deem (?PRED ?X ?X) impossible
  865.    simply because it is already pending and not good.")
  866. ;;; Result(144)  <==== #<INFERENCE-UNIT-TEST 0>
  867. ;;; CYC(145): (DEFINE-INFERENCE-UNIT-TEST :NO-GOOD-PROBLEMS-ARE-NOT-IMPOSSIBLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$different ?X ?X) (#$integerBetween 1 ?X 5) (#$performSubL (#$ExpandSubLFn (?X) (PWHEN (= ?X 1) (QUERY-ABORT))))))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$different ?X ?X) (#$integerBetween 1 ?X 6) (#$performSubL (#$ExpandSubLFn (?X) (PWHEN (= ?X 1) (QUERY-ABORT)))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "The first time the query is asked it should correctly focus on (#$different ?X ?X).
  868.    When the followup query is asked, no-goodness propagation should prevent any
  869.    any tactics from being executed.")
  870. ;;; Result(145)  <==== #<INFERENCE-UNIT-TEST 0>
  871. ;;; CYC(146): (DEFINE-INFERENCE-UNIT-TEST :POSSIBLE-REUSED-PROBLEMS-GET-STRATEGICALLY-EVALUATED :OWNER "goolsbey" :BUG 4664 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?P "a")) (#$ist #$UniversalVocabularyMt (?P "b")) (#$ist #$UniversalVocabularyMt (?Q "a")) (#$ist #$UniversalVocabularyMt (?R "b"))) (#$ist #$UniversalVocabularyMt (#$and (?P ?X) (?Q ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (?P ?X) (#$or (?Q ?X) (?R ?X)))) :PROPERTIES (:CONDITIONAL-SENTENCE? NIL :CONTINUABLE? NIL) :EXPECTED-RESULT (((?X . "a")) ((?X . "b"))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to make sure that adding a disjunct doesn't result
  872. in _fewer_ bindings because of the failure to evaluate a
  873. tactically possible reused problem wrt the new strategy.
  874. The completeExtentEnumerable gafs are necessary to ensure that
  875. it doesn't try both of the join-ordered tactics, and hence
  876. cause the problem to become tactically pending.
  877. Motivated by bug #4664.")
  878. ;;; Result(146)  <==== #<INFERENCE-UNIT-TEST 0>
  879. ;;; CYC(147): (DEFINE-INFERENCE-UNIT-TEST :PENDING-REUSED-PROBLEMS-GET-STRATEGICALLY-EVALUATED :OWNER "goolsbey" :BUG 7842 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (#$completeExtentEnumerable ?P)) (#$ist #$UniversalVocabularyMt (#$completeExtentEnumerable ?Q)) (#$ist #$UniversalVocabularyMt (#$completeExtentEnumerable ?R)) (#$ist #$UniversalVocabularyMt (?P "a")) (#$ist #$UniversalVocabularyMt (?P "b")) (#$ist #$UniversalVocabularyMt (?Q "a")) (#$ist #$UniversalVocabularyMt (?R "b"))) (#$ist #$UniversalVocabularyMt (#$and (?P ?X) (?Q ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (?P ?X) (#$or (?Q ?X) (?R ?X)))) :PROPERTIES (:CONDITIONAL-SENTENCE? NIL :CONTINUABLE? NIL) :EXPECTED-RESULT (((?X . "a")) ((?X . "b"))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to make sure that adding a disjunct doesn't result
  880. in _fewer_ bindings because of the failure to evaluate a
  881. tactically pending reused problem wrt the new strategy.")
  882. ;;; Result(147)  <==== #<INFERENCE-UNIT-TEST 0>
  883. ;;; CYC(148): (DEFINE-INFERENCE-UNIT-TEST :EVALUATABLE-FUNCTION-VIA-EXPANSION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$EvaluatableFunction) (#$expansion ?FUNC (#$TimesFn :ARG1 :ARG1))) (#$evaluate 64 (?FUNC 8))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "This ensures that evaluation works for #$EvaluatableFunctions with #$expansions.")
  884. ;;; Result(148)  <==== #<INFERENCE-UNIT-TEST 0>
  885. ;;; CYC(149): (DEFINE-INFERENCE-UNIT-TEST :EVALUATABLE-PREDICATE-VIA-EXPANSION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$EvaluatablePredicate) (#$expansion ?PRED (#$greaterThan :ARG1 :ARG2))) (?PRED 212 210)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "This ensures that evaluation works for #$EvaluatablePredicates with #$expansions.")
  886. ;;; Result(149)  <==== #<INFERENCE-UNIT-TEST 0>
  887. ;;; CYC(150): (DEFINE-INFERENCE-UNIT-TEST :FALSE-EVALUATABLE-PREDICATE-VIA-EXPANSION :OWNER "goolsbey" :BUG 12035 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$EvaluatablePredicate) (#$expansion ?PRED (#$greaterThan :ARG1 :ARG2))) (?PRED 210 212)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "This ensures that evaluation doesn't vacuously succeed
  888.    for #$EvaluatablePredicates with #$expansions.")
  889. ;;; Result(150)  <==== #<INFERENCE-UNIT-TEST 0>
  890. ;;; CYC(151): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-ITERATIVITY :OWNER "goolsbey" :BUG 4327 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$integerBetween 1 ?X 10))) :PROPERTIES (QUOTE (:MAX-NUMBER 2 :MAX-PROBLEM-COUNT 4)) :EXPECTED-RESULT (QUOTE (((?X . 1)) ((?X . 2)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "This should not generate all 10 answers just to generate the first 2.")
  891. ;;; Result(151)  <==== #<INFERENCE-UNIT-TEST 0>
  892. ;;; CYC(152): (DEFINE-INFERENCE-UNIT-TEST :UNEXAMINED-GOOD-FOLLOWUP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$genls #$Thing ?X) (#$different ?X 212)))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . #$Thing)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$genls #$Thing #$Thing)) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Simplest example of a followup whose problem is already unexamined good.
  893.    All it has to do is open the answer link to bubble up the already existing proofs.")
  894. ;;; Result(152)  <==== #<INFERENCE-UNIT-TEST 0>
  895. ;;; CYC(153): (DEFINE-INFERENCE-UNIT-TEST :RESTRICTED-CLOSED-GOOD-PROBLEMS-STAY-UNEXAMINED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 2 ?X 4)))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (TACTICALLY-UNEXAMINED-PROBLEM-P (FIND-PROBLEM-BY-QUERY (CURRENTLY-ACTIVE-PROBLEM-STORE) (ASENT-SENSE-AND-MT-TO-PROBLEM-QUERY (QUOTE (#$integerBetween 1 2 2)) :POS #$UniversalVocabularyMt)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "This test verifies that the closed good problem (#$integerBetween 1 2 2)
  896.    which gets added via :add-restriction-layer-of-indirection? stays
  897.    tactically unexamined.  This is an important efficiency assumption.")
  898. ;;; Result(153)  <==== #<INFERENCE-UNIT-TEST 0>
  899. ;;; CYC(154): (DEFINE-INFERENCE-UNIT-TEST :TERM-OF-UNIT-IS-NOT-COMPLETELY-ENUMERABLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$ist #$UniversalVocabularyMt (?PRED 1)) (#$ist #$UniversalVocabularyMt (?PRED 2)) (#$ist #$UniversalVocabularyMt (?PRED 3)) (#$comment (?FUNC 212) "think of this nart")) (#$and (#$ist #$UniversalVocabularyMt (?PRED ?X)) (#$termOfUnit ?NAT (?FUNC ?X)))))) :EXPECTED-RESULT (QUOTE (((?X . 1) (?NAT ?FUNC 1)) ((?X . 2) (?NAT ?FUNC 2)) ((?X . 3) (?NAT ?FUNC 3)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :BROWSABLE? T)) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (ZEROP (PROBLEM-DISCARDED-TACTIC-COUNT (FIND-PROBLEM-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "This test verifies that none of the tactics on the root problem are discarded,
  900. because the only way that would happen is if the #$termOfUnit literal were deemed complete,
  901. and it oughtn't be deemed complete.")
  902. ;;; Result(154)  <==== #<INFERENCE-UNIT-TEST 0>
  903. ;;; CYC(155): (DEFINE-INFERENCE-UNIT-TEST :SMALL-PROBLEM-STORE-PRUNING-MIN-SUFFICIENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$elementOf ?A (#$TheSet 7 8 9)) (#$elementOf ?B (#$TheSet 70 80 90)) (#$elementOf ?C (#$TheSet 700 800 900)) (#$evaluate 999 (#$PlusFn ?A ?B ?C))))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 26 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?A . 9) (?B . 90) (?C . 900)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to make sure that problem store pruning can prune exponential
  904. problem store explosion into polynomial")
  905. ;;; Result(155)  <==== #<INFERENCE-UNIT-TEST 0>
  906. ;;; CYC(156): (DEFINE-INFERENCE-UNIT-TEST :PROBLEM-STORE-PRUNING-MIN-SUFFICIENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$elementOf ?A (#$TheSet 0 1 2 3 4 5 6 7 8 9)) (#$elementOf ?B (#$TheSet 0 10 20 30 40 50 60 70 80 90)) (#$elementOf ?C (#$TheSet 0 100 200 300 400 500 600 700 800 900)) (#$evaluate 999 (#$PlusFn ?A ?B ?C))))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 68 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?A . 9) (?B . 90) (?C . 900)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to make sure that problem store pruning can prune exponential
  907. problem store explosion into polynomial")
  908. ;;; Result(156)  <==== #<INFERENCE-UNIT-TEST 0>
  909. ;;; CYC(157): (DEFINE-INFERENCE-UNIT-TEST :PROBLEM-STORE-PRUNING-MAX-INSUFFICIENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$elementOf ?A (#$TheSet 0 1 2 3 4 5 6 7 8 9)) (#$elementOf ?B (#$TheSet 0 10 20 30 40 50 60 70 80 90)) (#$elementOf ?C (#$TheSet 0 100 200 300 400 500 600 700 800 900)) (#$evaluate 999 (#$PlusFn ?A ?B ?C))))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 67 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :MAX-PROBLEM-COUNT :COMMENT "Test to make sure that problem store pruning can prune exponential
  910. problem store explosion into polynomial -- it should need at most
  911. 86 problems and should fail when only given 85 problems.")
  912. ;;; Result(157)  <==== #<INFERENCE-UNIT-TEST 0>
  913. ;;; CYC(158): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-NOT-CANONICALIZATION :OWNER "jantos" :BUG 3271 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) (#$assertionDirection (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) #$Forward-AssertionDirection) (?PRED (#$isa ?TERM #$Collection) (#$not (#$isa #$Thing ?TERM)))) (#$not (#$isa #$Thing ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether a rule which concludes (#$trueSentence (#$not X)) concludes (#$not X).")
  914. ;;; Result(158)  <==== #<INFERENCE-UNIT-TEST 0>
  915. ;;; CYC(159): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-AND-CANONICALIZATION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) (#$assertionDirection (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) #$Forward-AssertionDirection) (?PRED (#$isa ?TERM #$Collection) (#$and (#$isa ?TERM #$Thing) (#$isa ?TERM #$SetOrCollection)))) (#$and (#$isa ?TERM #$Thing) (#$isa ?TERM #$SetOrCollection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether a rule which concludes (#$trueSentence (#$and X Y)) concludes X and Y.")
  916. ;;; Result(159)  <==== #<INFERENCE-UNIT-TEST 0>
  917. ;;; CYC(160): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-OR-CANONICALIZATION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) (#$assertionDirection (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) #$Forward-AssertionDirection) (?PRED (#$isa ?TERM #$Collection) (#$or (#$isa ?TERM #$Thing) (#$isa ?TERM #$SetOrCollection)))) (#$or (#$isa ?TERM #$Thing) (#$isa ?TERM #$SetOrCollection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether a rule which concludes (#$trueSentence (#$or X Y)) concludes X or Y.")
  918. ;;; Result(160)  <==== #<INFERENCE-UNIT-TEST 0>
  919. ;;; CYC(161): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-IMPLIES-CANONICALIZATION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) (#$assertionDirection (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) #$Forward-AssertionDirection) (?PRED (#$isa ?TERM #$Thing) (#$implies (#$isa ?TERM #$Collection) (#$isa ?TERM #$SetOrCollection)))) (#$implies (#$isa ?TERM #$Collection) (#$isa ?TERM #$SetOrCollection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether a rule which concludes (#$trueSentence (#$implies X Y)) concludes (#$implies X Y).")
  920. ;;; Result(161)  <==== #<INFERENCE-UNIT-TEST 0>
  921. ;;; CYC(162): (DEFINE-INFERENCE-UNIT-TEST :MAX-PRODUCTIVITY-LIMIT-UNANSWERABLE :OWNER "goolsbey" :BUG 4324 :SENTENCE (QUOTE (#$ist #$BaseKB (#$integerBetween 1 ?N 5))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 499)) :EXPECTED-RESULT NIL :COMMENT "Checks whether the inference fails if the productivity limit is set
  922. below the one needed to get the answer.  This is to check that
  923. productivity limit works. It is related to Bug 4324 - to check that
  924. as the old inference engine only used one value for
  925. *removal-cost-cutoff*, the new inference engine should allow
  926. setting the productivity limit - the new inference engine
  927. equivalent of *removal-cost-cutoff*")
  928. ;;; Result(162)  <==== #<INFERENCE-UNIT-TEST 0>
  929. ;;; CYC(163): (DEFINE-INFERENCE-UNIT-TEST :MIN-PRODUCTIVITY-LIMIT-ANSWERABLE :OWNER "goolsbey" :BUG 4324 :SENTENCE (QUOTE (#$ist #$BaseKB (#$integerBetween 1 ?N 5))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 501)) :EXPECTED-RESULT (QUOTE (((?N . 1)) ((?N . 2)) ((?N . 3)) ((?N . 4)) ((?N . 5)))) :COMMENT "Checks whether the inference succeeds if the productivity limit is
  930.   set above the one needed to get the answer.  This is to check that
  931.   productivity limit works. It is related to Bug 4324 - to check
  932.   that as the old inference engine only used one value for
  933.   *removal-cost-cutoff*, the new inference engine should allow
  934.   setting the productivity limit - the new inference engine
  935.   equivalent of *removal-cost-cutoff*")
  936. ;;; Result(163)  <==== #<INFERENCE-UNIT-TEST 0>
  937. ;;; CYC(164): (DEFINE-INFERENCE-UNIT-TEST :CONSTANT-NAME-STORAGE-MODULE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?TERM #$Thing) (#$constantName ?TERM "Arglefarb212")) (#$constantName ?TERM "Arglefarb212")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether the #$constantName HL storage module can correctly modify a constant name.")
  938. ;;; Result(164)  <==== #<INFERENCE-UNIT-TEST 0>
  939. ;;; CYC(165): (PROGN (DEFGLOBAL-PRIVATE *PERFORM-SUBL-STORAGE-MODULE-HELPER* NIL) (DEFINE-INFERENCE-UNIT-TEST :PERFORM-SUBL-STORAGE-MODULE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$performSubL (#$SubLQuoteFn (CSETQ *PERFORM-SUBL-STORAGE-MODULE-HELPER* "success"))) (#$trueSubL (#$SubLQuoteFn (EQUAL *PERFORM-SUBL-STORAGE-MODULE-HELPER* "success")))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether the #$performSubL HL storage module can correctly perform a side-effect."))
  940. ;;; Result(165)  <==== #<INFERENCE-UNIT-TEST 0>
  941. ;;; CYC(166): (DEFINE-INFERENCE-UNIT-TEST :INDEXICAL-THE-USER :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?TERM #$HumanCyclist) (#$trueSubL (#$ExpandSubLFn (?TERM) (CLET (ANSWER) (WITH-THE-CYCLIST (?TERM) (CSETQ ANSWER (NEW-CYC-QUERY (QUOTE (#$indexicalReferent #$TheUser ?TERM)) #$UniversalVocabularyMt))) (BOOLEAN ANSWER))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether the #$indexicalReferent #$TheUser module deals with rebinding the Cyclist properly.")
  942. ;;; Result(166)  <==== #<INFERENCE-UNIT-TEST 0>
  943. ;;; CYC(167): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-OF-ATOMIC-SENTENCE-REDUCTION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$equalSymbols ?SENTENCE (#$isa 213 #$Integer)) (#$trueSentence ?SENTENCE)))) :PROPERTIES (QUOTE (:ANSWER-LANGUAGE :HL :RETURN :SUPPORTS)) :EXPECTED-RESULT (QUOTE (((:DEFN . :ANYTHING) :ANYTHING))) :EXPECTED-RESULT-TEST (QUOTE TREE-MATCHES-PATTERN) :COMMENT "Checks whether the inference czer properly reduces
  944.    (#$trueSentence (<predicate> . <args>)) to
  945.    (<predicate> . <args>)")
  946. ;;; Result(167)  <==== #<INFERENCE-UNIT-TEST 0>
  947. ;;; CYC(168): (DEFINE-INFERENCE-UNIT-TEST :IST-OF-ATOMIC-SENTENCE-REDUCTION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$equalSymbols ?SENTENCE (#$ist #$BaseKB (#$isa 213 #$Integer))) (#$trueSentence ?SENTENCE)))) :PROPERTIES (QUOTE (:ANSWER-LANGUAGE :HL :RETURN :SUPPORTS)) :EXPECTED-RESULT (QUOTE (((:DEFN :ANYTHING #$BaseKB :ANYTHING) :ANYTHING))) :EXPECTED-RESULT-TEST (QUOTE TREE-MATCHES-PATTERN) :COMMENT "Checks whether the inference czer properly reduces
  948.    (#$ist <mt> (<predicate> . <args>)) to
  949.    (<predicate> . <args>) in <mt>")
  950. ;;; Result(168)  <==== #<INFERENCE-UNIT-TEST 0>
  951. ;;; CYC(169): (DEFINE-INFERENCE-UNIT-TEST :FUNCTIONAL-RELATION-ALL-INSTANCE-ARGUMENTATION :OWNER "goolsbey" :WORKING? NIL :BUG 5962 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$FunctionalPredicate) (#$arg2Format ?PRED #$SingleEntry) (#$isa ?GENL-COL #$Collection) (#$genls ?GENL-COL #$Individual) (#$isa ?SPEC-COL #$Collection) (#$genls ?SPEC-COL ?GENL-COL) (#$isa ?TERM ?SPEC-COL) (#$relationAllInstance ?PRED ?GENL-COL "no") (#$relationAllInstance ?PRED ?SPEC-COL "yes")) (?PRED ?TERM ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "yes")))) :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Checks whether a value from a more specific collection overrides
  952.    a value from a more general collection in #$relationAllInstance
  953.    for a predicate that's functional in arg 2.")
  954. ;;; Result(169)  <==== #<INFERENCE-UNIT-TEST 0>
  955. ;;; CYC(170): (DEFINE-INFERENCE-UNIT-TEST :ALLOWED-MODULES-OBEYED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 213 #$Integer))) :PROPERTIES (QUOTE (:BROWSABLE? T :ALLOWED-MODULES (:AND (:MODULE-TYPE :REMOVAL) (:NOT :REMOVAL-ISA-DEFN-POS)))) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection)) :PROPERTIES (:BROWSABLE? T :ALLOWED-MODULES (:AND (:MODULE-TYPE :REMOVAL) (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT (NIL)) (:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$isa #$Individual #$Collection) (#$isa #$Collection #$Collection))) :PROPERTIES (:ALLOWED-MODULES (:AND (:MODULE-TYPE :REMOVAL) (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT NIL))) :COMMENT "A minimal trio that shows that :allowed-modules is working correctly,
  956.    along with :and, :not and :module-type patterns.")
  957. ;;; Result(170)  <==== #<INFERENCE-UNIT-TEST 0>
  958. ;;; CYC(171): (DEFINE-INFERENCE-UNIT-TEST :ALLOWED-MODULES-OBEYED-NOT-JOIN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate)) (#$and (?P ?WHAT) (?Q ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (CNOT (PROBLEM-HAS-TACTIC-OF-TYPE-WITH-STATUS? (FIND-PROBLEM-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0) :JOIN :EXECUTED))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that :allowed-modules (:not :join) really stops it
  959. from picking join links.")
  960. ;;; Result(171)  <==== #<INFERENCE-UNIT-TEST 0>
  961. ;;; CYC(172): (DEFINE-INFERENCE-UNIT-TEST :ALLOWED-MODULES-OBEYED-BY-META-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?THING #$Thing) (#$completeExtentEnumerableForValueInArg #$isa ?THING 1)) (#$isa ?THING #$Thing)))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :REMOVAL-ISA-COLLECTION-CHECK-POS))) :EXPECTED-RESULT NIL :COMMENT "Test that meta-removal tactics obey :allowed-modules.
  962. There used to be a bug in which executing a meta-removal tactic
  963. would execute /all/ the other tactics on the problem, regardless
  964. of whether they were disallowed.")
  965. ;;; Result(172)  <==== #<INFERENCE-UNIT-TEST 0>
  966. ;;; CYC(173): (DEFINE-INFERENCE-UNIT-TEST :FOLLOWUP-LOOK-AT-IT-BEFORE-YOU-THROW-IT-AWAY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$quotedIsa ?N #$SubLInteger) (#$integerBetween 1 ?N 2) (#$equalSymbols ?N 1)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?N . 1)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$quotedIsa ?N #$SubLInteger) (#$integerBetween 1 ?N 2) (#$equalSymbols ?N 2))) :EXPECTED-RESULT (((?N . 2)))))) :COMMENT "Test that verifies that a followup that shares common parts is answerable.
  967. This test used to fail because a problem was being deemed impossible by
  968. the second strategy because it was strategically unexamined.  The second
  969. strategy needs to strategically examine it before it does anything else.")
  970. ;;; Result(173)  <==== #<INFERENCE-UNIT-TEST 0>
  971. ;;; CYC(174): (DEFINE-INFERENCE-UNIT-TEST :UNREIFIABLE-CONSTANT-DENOTING-FUNCTION-TO-ARG :OWNER "jantos" :WORKING? NIL :BUG 6764 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?CONSTANT-NAME #$BinaryPredicate) (#$arg1Isa ?CONSTANT-NAME #$CycLConstant) (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM #$Individual) (?PRED ?TERM ((#$FunctionToArg 1 ?CONSTANT-NAME) ?TERM))) (?PRED ?TERM ((#$FunctionToArg 1 ?CONSTANT-NAME) ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a constant-denoting #$FunctionToArg naut is not deemed
  972. reifiable by the canonicalizer.")
  973. ;;; Result(174)  <==== #<INFERENCE-UNIT-TEST 0>
  974. ;;; CYC(175): (DEFINE-INFERENCE-UNIT-TEST :UNREIFIABLE-REIFIABLE-FUNCTION-DENOTING-NAUT :OWNER "jantos" :WORKING? NIL :BUG 7148 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$UnreifiableFunction) (#$resultIsa ?FUNC #$ReifiableFunction) ((?FUNC 212) 212)) ((?FUNC 212) 212)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can handle unreifiable ReifiableFunction-denoting nauts.")
  975. ;;; Result(175)  <==== #<INFERENCE-UNIT-TEST 0>
  976. ;;; CYC(176): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-SPLIT-WITH-META-REMOVAL :OWNER "goolsbey" :BUG 9163 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?PRED-1-SPEC #$UnaryPredicate) (#$isa ?PRED-2 #$UnaryPredicate) (#$genlPreds ?PRED-1-SPEC ?PRED-1) (#$completeExtentEnumerable ?PRED-1) (#$completeExtentEnumerable ?PRED-2) (?PRED-1 "a") (?PRED-2 "b") (?PRED-2 "c")) (#$and (?PRED-1 "a") (?PRED-2 "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "A split in which the first half is closed and becomes good via a meta-removal
  977.    module executing another tactic.")
  978. ;;; Result(176)  <==== #<INFERENCE-UNIT-TEST 0>
  979. ;;; CYC(177): (DEFINE-INFERENCE-UNIT-TEST :RELATION-ALL-INSTANCE-ITERATE-1 :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?COL-TERM-1 #$BinaryPredicate) (#$isa ?COL-TERM-2 #$BinaryPredicate) (#$isa ?COL-TERM-1 ?COL) (#$isa ?COL-TERM-2 ?COL) (#$isa ?ARG #$Collection) (#$isa ?FUNC-TYPE #$Collection) (#$isa ?FUNC-1 #$Function-Denotational) (#$isa ?FUNC-2 #$Function-Denotational) (#$isa ?FUNC-1 ?FUNC-TYPE) (#$isa ?FUNC-2 ?FUNC-TYPE) (#$relationAllInstance #$arg1Isa ?COL ?ARG) (#$relationAllInstance #$resultIsa ?FUNC-TYPE ?ARG)) (#$arg1Isa ?WHAT ?ARG)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL-TERM-1)) ((?WHAT . ?COL-TERM-2)))) :COMMENT "Test that relationAllInstance returns only the correct answers.")
  980. ;;; Result(177)  <==== #<INFERENCE-UNIT-TEST 0>
  981. ;;; CYC(178): (DEFINE-INFERENCE-UNIT-TEST :RELATION-ALL-INSTANCE-ITERATE-2 :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?COL-TERM-1 #$BinaryPredicate) (#$isa ?COL-TERM-1 ?COL) (#$isa ?ARG #$Collection) (#$ist #$BaseKB (#$relationAllInstance #$arg1Isa ?COL ?ARG)) (#$ist #$UniversalVocabularyMt (#$relationAllInstance #$arg1Isa ?COL ?ARG))) (#$arg1Isa ?WHAT ?ARG)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RESULT-UNIQUENESS :PROOF :RETURN :BINDINGS-AND-SUPPORTS)) :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-RESULT 2 :COMMENT "Test that relationAllInstance returns the correct number of supports.")
  982. ;;; Result(178)  <==== #<INFERENCE-UNIT-TEST 0>
  983. ;;; CYC(179): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-ALL-ITERATE-1 :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?ARG-TYPE #$Collection) (#$isa ?ARG-TYPE-1 #$Collection) (#$isa ?ARG-TYPE-2 #$Collection) (#$isa ?ARG-TYPE-1 ?ARG-TYPE) (#$isa ?ARG-TYPE-2 ?ARG-TYPE) (#$isa ?ARG-TYPE #$Collection) (#$isa ?FAKE-ARG-TYPE-1 #$Collection) (#$isa ?FAKE-ARG-TYPE-2 #$Collection) (#$isa ?FAKE-ARG-TYPE-1 ?FAKE-ARG-TYPE) (#$isa ?FAKE-ARG-TYPE-2 ?FAKE-ARG-TYPE) (#$relationInstanceAll #$arg1Isa ?PRED ?ARG-TYPE) (#$relationInstanceAll #$resultIsa ?PRED ?FAKE-ARG-TYPE)) (#$arg1Isa ?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?ARG-TYPE-1)) ((?WHAT . ?ARG-TYPE-2)))) :COMMENT "Test that relationInstanceAll returns only the correct answers.")
  984. ;;; Result(179)  <==== #<INFERENCE-UNIT-TEST 0>
  985. ;;; CYC(180): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-ALL-ITERATE-2 :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?ARG-TYPE #$Collection) (#$isa ?ARG-TYPE-1 ?ARG-TYPE) (#$isa ?ARG-TYPE-1 #$Collection) (#$ist #$BaseKB (#$relationInstanceAll #$arg1Isa ?PRED ?ARG-TYPE)) (#$ist #$UniversalVocabularyMt (#$relationInstanceAll #$arg1Isa ?PRED ?ARG-TYPE))) (#$arg1Isa ?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RESULT-UNIQUENESS :PROOF :RETURN :BINDINGS-AND-SUPPORTS)) :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-RESULT 2 :COMMENT "Test that relationInstanceAll returns the correct number of supports.")
  986. ;;; Result(180)  <==== #<INFERENCE-UNIT-TEST 0>
  987. ;;; CYC(181): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-NAT-FUNCTION-NAT-ARGUMENT-DOESNT-SKOLEMIZE :OWNER "goolsbey" :BUG 9715 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM-1 ?COL) (#$isa ?TERM-2 ?COL) (#$completelyEnumerableCollection ?COL) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$arg1Isa ?FUNC ?COL) (#$comment (?FUNC ?TERM-1) "Think of this NART.")) (#$and (#$isa ?TERM ?COL) (#$natFunction ?NAT ?FUNC) (#$natArgument ?NAT 1 ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ANSWER-LANGUAGE :EL :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ALLOWED-MODULES (:AND (:NOT :REMOVAL-NAT-FUNCTION-LOOKUP) (:NOT :REMOVAL-NAT-ARGUMENT-LOOKUP)))) :EXPECTED-RESULT (QUOTE (((?NAT ?FUNC ?TERM-1) (?TERM . ?TERM-1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "The conjunctive removal module for #$natFunction & #$natArgument should not reify new NARTs,
  988.    in this case (?FUNC ?TERM-2)")
  989. ;;; Result(181)  <==== #<INFERENCE-UNIT-TEST 0>
  990. ;;; CYC(182): (DEFINE-INFERENCE-UNIT-TEST :REJECT-GENLPREDS-PROOF :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg1Isa ?GENL-PRED ?COL-2) (#$isa ?TERM-1 ?COL-1) (#$not (#$isa ?TERM-1 ?COL-2)) (#$isa ?TERM-2 ?COL-1) (#$isa ?TERM-2 ?COL-2) (?SPEC-PRED ?TERM-1) (?SPEC-PRED ?TERM-2)) (?GENL-PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-2)))) :COMMENT "The genlPreds proof for (?GENL-PRED ?TERM-1)
  991.    should be rejected due to intermediate step validation.")
  992. ;;; Result(182)  <==== #<INFERENCE-UNIT-TEST 0>
  993. ;;; CYC(183): (DEFINE-INFERENCE-UNIT-TEST :REUSE-REJECTED-PROOF :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg1Isa ?GENL-PRED ?COL-2) (#$isa ?TERM-1 ?COL-1) (#$not (#$isa ?TERM-1 ?COL-2)) (#$isa ?TERM-2 ?COL-1) (#$isa ?TERM-2 ?COL-2) (?SPEC-PRED ?TERM-1) (?SPEC-PRED ?TERM-2)) (?GENL-PRED ?TERM-1)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$thereExists ?HYP-MT (#$and (#$ist-Asserted ?HYP-MT (?SPEC-PRED ?TERM-1)) (#$ist ?HYP-MT (?GENL-PRED ?WHAT))))) :EXPECTED-RESULT (((?WHAT . ?TERM-2))) :PROPERTIES (:RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)))) :COMMENT "The rejected genlPreds proof for (?GENL-PRED ?TERM-1)
  994.    should be reused when the proof for
  995.      (?GENL-PRED ?WHAT) where ((?WHAT . ?TERM-1))
  996.    is considered, even though the reused proof is rejected.")
  997. ;;; Result(183)  <==== #<INFERENCE-UNIT-TEST 0>
  998. ;;; CYC(184): (DEFINE-INFERENCE-UNIT-TEST :ANOTHER-REJECTED-PROOF-ON-UNEXAMINED-NO-GOOD :OWNER "goolsbey" :BUG 9988 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?SPEC-PRED-1 #$UnaryPredicate) (#$isa ?SPEC-PRED-2 #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED-1 ?GENL-PRED) (#$genlPreds ?SPEC-PRED-2 ?GENL-PRED) (#$arg1Isa ?SPEC-PRED-1 ?COL-1) (#$arg1Isa ?SPEC-PRED-2 ?COL-1) (#$arg1Isa ?GENL-PRED ?COL-2) (#$isa ?TERM-1 ?COL-1) (#$not (#$isa ?TERM-1 ?COL-2)) (#$isa ?TERM-2 ?COL-1) (#$isa ?TERM-2 ?COL-2) (?SPEC-PRED-1 ?TERM-1) (?SPEC-PRED-1 ?TERM-2) (?SPEC-PRED-2 ?TERM-1) (?SPEC-PRED-2 ?TERM-2)) (?GENL-PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONTINUABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-2)))) :EXPECTED-HALT-REASON :EXHAUST :COMMENT "The 2 different genlPreds proofs for (?GENL-PRED ?TERM-1)
  999.    should both be rejected due to intermediate step validation.
  1000.    The second one should be on an :UNEXAMINED-NO-GOOD problem")
  1001. ;;; Result(184)  <==== #<INFERENCE-UNIT-TEST 0>
  1002. ;;; CYC(185): (DEFINE-INFERENCE-UNIT-TEST :ANOTHER-REJECTED-PROOF-ON-PENDING-NO-GOOD :OWNER "goolsbey" :BUG 5987 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?SPEC-PRED-1 #$UnaryPredicate) (#$isa ?SPEC-PRED-2 #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?SPEC-PRED-1 ?GENL-PRED) (#$genlPreds ?SPEC-PRED-2 ?GENL-PRED) (#$arg1Isa ?SPEC-PRED-1 ?COL-1) (#$arg1Isa ?SPEC-PRED-2 ?COL-1) (#$arg1Isa ?GENL-PRED ?COL-2) (#$isa ?TERM-1 ?COL-1) (#$not (#$isa ?TERM-1 ?COL-2)) (#$isa ?TERM-2 ?COL-1) (#$isa ?TERM-2 ?COL-2) (?SPEC-PRED-1 ?TERM-1) (?SPEC-PRED-1 ?TERM-2) (?SPEC-PRED-2 ?TERM-1) (?SPEC-PRED-2 ?TERM-2)) (?GENL-PRED ?TERM-1)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT NIL :COMMENT "The 2 different genlPreds proofs for (?GENL-PRED ?TERM-1)
  1003.    should both be rejected due to intermediate step validation.
  1004.    The second one should be on a :PENDING-NO-GOOD problem")
  1005. ;;; Result(185)  <==== #<INFERENCE-UNIT-TEST 0>
  1006. ;;; CYC(186): (DEFINE-INFERENCE-UNIT-TEST :RETRACT-INFERENCE-ANSWER :OWNER "goolsbey" :WORKING? NIL :BUG 10196 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?GENL-PRED #$BinaryPredicate) (#$isa ?SPEC-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg2Isa ?SPEC-PRED ?COL-1) (#$isa ?TERM ?COL-1) (#$not (#$isa ?TERM ?COL-2)) (?GENL-PRED ?TERM ?TERM) (?SPEC-PRED ?TERM ?TERM) (#$arg1Isa ?GENL-PRED ?COL-2) (#$arg2Isa ?GENL-PRED ?COL-2)) (?GENL-PRED ?TERM ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "The inference answer generated via the asserted
  1007.    (?GENL-PRED ?TERM ?TERM) support will later
  1008.    be rejected by intermediate step validation of
  1009.    a different, more complicated proof involving
  1010.    (#$genlPreds ?SPEC-PRED ?GENL-PRED).  This will
  1011.    require retraction of the first answer.")
  1012. ;;; Result(186)  <==== #<INFERENCE-UNIT-TEST 0>
  1013. ;;; CYC(187): (DEFINE-INFERENCE-UNIT-TEST :REJECT-PREVIOUSLY-PROVEN-PROOFS :OWNER "goolsbey" :BUG 6790 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?GENL-PRED #$BinaryPredicate) (#$isa ?SPEC-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg2Isa ?SPEC-PRED ?COL-1) (#$isa ?TERM ?COL-1) (#$not (#$isa ?TERM ?COL-2)) (?GENL-PRED ?TERM ?TERM) (?SPEC-PRED ?TERM ?TERM) (?SPEC-PRED ?TERM "chaff") (#$arg1Isa ?GENL-PRED ?COL-2) (#$arg2Isa ?GENL-PRED ?COL-2)) (#$and (?GENL-PRED ?TERM ?WHAT) (#$integerBetween 1 ?X 14))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :RESULT-UNIQUENESS :PROOF :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL)) :EXPECTED-RESULT (QUOTE (((?X . 1) (?WHAT . ?TERM)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE))) (CAND (PROOF-REJECTED? (FIND-PROOF-BY-ID STORE 0)) (PROOF-REJECTED? (FIND-PROOF-BY-ID STORE 1)) (PROOF-REJECTED? (FIND-PROOF-BY-ID STORE 2)) (PROOF-REJECTED? (FIND-PROOF-BY-ID STORE 3))))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Ensures that all the proofs for
  1014.    ((?WHAT . ?TERM)) on (?GENL-PRED ?TERM ?WHAT)
  1015.    and the proofs for (?GENL-PRED ?TERM ?TERM)
  1016.    are rejected once the genlPreds proof for
  1017.    (?GENL-PRED ?TERM ?TERM) is rejected.")
  1018. ;;; Result(187)  <==== #<INFERENCE-UNIT-TEST 0>
  1019. ;;; CYC(188): (DEFINE-INFERENCE-UNIT-TEST :CONSIDER-NO-GOOD-AFTER-DETERMINING-TACTICS :OWNER "goolsbey" :BUG 10471 :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$equalSymbols ?DIFFERENT #$different) (?DIFFERENT 2 ?X 2)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$different 2 ?Y ?X) (#$integerBetween ?X ?Y 3) (#$different 2 ?Z ?Y) (#$integerBetween 1 ?Z ?Y))) :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT (((?X . 1) (?Y . 3) (?Z . 1)))) (:SENTENCE (#$ist #$BaseKB (#$evaluate ?COUNT (#$EvaluateSubLFn (#$SubLQuoteFn (PROBLEM-DISCARDED-TACTIC-COUNT (FIND-PROBLEM-BY-QUERY (CURRENTLY-ACTIVE-PROBLEM-STORE) (CANONICALIZE-PROBLEM-QUERY (CANONICALIZE-DEFAULT-EL-VARS (DNF-AND-MT-TO-HL-QUERY (QUOTE (NIL ((#$different ?VAR0 ?VAR1 2) (#$different 2 ?VAR0 2) (#$integerBetween 1 ?VAR1 ?VAR0) (#$integerBetween 2 ?VAR0 3)))) #$BaseKB))))))))) :EXPECTED-RESULT (((?COUNT . 4)))))) :COMMENT "As soon as the logical tactics for
  1020.  
  1021.    (#$and
  1022.      (#$different 2 ?Y 2)
  1023.      (#$integerBetween 2 ?Y 3)
  1024.      (#$different 2 ?Z ?Y)
  1025.      (#$integerBetween 1 ?Z ?Y))
  1026.    
  1027.    are determined, the problem should be immediately deemed no-good, since
  1028.  
  1029.      (#$different 2 ?Y 2)
  1030.  
  1031.    was already proven no-good by earlier work.
  1032.    This in turn should result in all 3 tactics being discarded.")
  1033. ;;; Result(188)  <==== #<INFERENCE-UNIT-TEST 0>
  1034. ;;; CYC(189): (DEFINE-INFERENCE-UNIT-TEST :FOUR-DIFFERENT-TERMS-CAN-BE-EQUAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?OBJ-1 #$Individual) (#$isa ?OBJ-2 #$Individual) (#$isa ?OBJ-3 #$Individual) (#$isa ?OBJ-4 #$Individual) (#$equals ?OBJ-1 ?OBJ-2) (#$equals ?OBJ-1 ?OBJ-3) (#$equals ?OBJ-1 ?OBJ-4) (#$equals ?OBJ-2 ?OBJ-3) (#$equals ?OBJ-2 ?OBJ-4) (#$equals ?OBJ-3 ?OBJ-4)) (#$and (#$differentSymbols ?OBJ-1 ?OBJ-2 ?OBJ-3 ?OBJ-4) (#$equals ?OBJ-1 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?OBJ-1)) ((?WHAT . ?OBJ-2)) ((?WHAT . ?OBJ-3)) ((?WHAT . ?OBJ-4)))) :COMMENT "Ensure that 4 different terms can be equal.
  1035.    This test exists to ensure that #$equals does not have any
  1036.    single-entry constraint on its args that doesn't take into
  1037.    account the difference between #$equals and #$equalSymbols.")
  1038. ;;; Result(189)  <==== #<INFERENCE-UNIT-TEST 0>
  1039. ;;; CYC(190): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-EQUALITY-REASONING :OWNER "pace" :WORKING? NIL :BUG 10946 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$equals ?B ?A) (?PRED ?A)) (?PRED ?B)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that simple equality reasoning works.")
  1040. ;;; Result(190)  <==== #<INFERENCE-UNIT-TEST 0>
  1041. ;;; CYC(191): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-EQUALITY-REASONING-QUOTED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$quotedArgument ?PRED 1) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$equals ?B ?A) (?PRED ?A)) (?PRED ?B)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Just like @xref :simple-equality-reasoning except
  1042. the arg1 of ?PRED is quoted, and hence the conclusion ought not be provable.")
  1043. ;;; Result(191)  <==== #<INFERENCE-UNIT-TEST 0>
  1044. ;;; CYC(192): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-REWRITE-OF :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$rewriteOf ?B ?A) (?PRED ?A)) (?PRED ?B)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Just like @xref :simple-equality-reasoning except
  1045. uses #$rewriteOf instead of #$equals.")
  1046. ;;; Result(192)  <==== #<INFERENCE-UNIT-TEST 0>
  1047. ;;; CYC(193): (DEFINE-INFERENCE-UNIT-TEST :INFERENCE-HARNESS-OVERHEAD :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf ?DIGIT-0 (#$TheSet 0 1 2 3 4 5 6 7 8 9)) (#$elementOf ?DIGIT-1 (#$TheSet 0 10 20 30 40 50 60 70 80 90)) (#$elementOf ?DIGIT-2 (#$TheSet 0 100 200 300 400 500 600 700 800 900)) (#$evaluate ?SUM (#$PlusFn ?DIGIT-2 ?DIGIT-1 ?DIGIT-0))))) :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-RESULT 1000 :COMMENT "A test for doing time and space profiles for a query that generates lots of answers.")
  1048. ;;; Result(193)  <==== #<INFERENCE-UNIT-TEST 0>
  1049. ;;; CYC(194): (PROGN (DEFINE-PRIVATE STRATEGICALLY-UNEXAMINED-NO-GOOD-HELPER (STORE GENL-PRED TERM) (CLET ((FIRST-INFERENCE (FIND-INFERENCE-BY-ID STORE 0)) (PROOF-MT (FIRST (INFERENCE-HL-MTS FIRST-INFERENCE))) (STRATEGY (SIMPLEST-INFERENCE-STRATEGY FIRST-INFERENCE)) (PROBLEM (FIND-PROBLEM-BY-QUERY STORE (ASENT-SENSE-AND-MT-TO-PROBLEM-QUERY (BQ-LIST GENL-PRED TERM TERM) :POS PROOF-MT)))) (RET (CAND PROBLEM (TACTICALLY-NO-GOOD-PROBLEM-P PROBLEM) (STRATEGICALLY-NO-GOOD-PROBLEM-P PROBLEM STRATEGY))))) (DEFINE-INFERENCE-UNIT-TEST :TACTICALLY-UNEXAMINED-NO-GOOD-IMPLIES-STRATEGICALLY-UNEXAMINED-NO-GOOD :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?COL-2 #$Collection) (#$isa ?GENL-PRED #$BinaryPredicate) (#$isa ?SPEC-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$arg1Isa ?SPEC-PRED ?COL-1) (#$arg2Isa ?SPEC-PRED ?COL-1) (#$isa ?TERM ?COL-1) (#$not (#$isa ?TERM ?COL-2)) (?GENL-PRED ?TERM ?TERM) (?SPEC-PRED ?TERM ?TERM) (?SPEC-PRED ?TERM "chaff") (#$arg1Isa ?GENL-PRED ?COL-2) (#$arg2Isa ?GENL-PRED ?COL-2)) (#$and (?GENL-PRED ?TERM ?WHAT) (#$integerBetween 1 ?X 14))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL :RESULT-UNIQUENESS :PROOF :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM) (?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (STRATEGICALLY-UNEXAMINED-NO-GOOD-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?GENL-PRED ?TERM)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A tactically unexamined no-good problem should also be strategically unexamined no-good."))
  1050. ;;; Result(194)  <==== #<INFERENCE-UNIT-TEST 0>
  1051. ;;; CYC(195): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-PRUNE-DONT-PRUNE-GOOD :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-2 #$Collection) (#$completelyDecidableCollection ?COL-2) (#$isa ?INS-2-A ?COL-2) (#$isa ?INS-2-B ?COL-2) (#$isa ?INS-2-C ?COL-2) (#$isa ?COL-3 #$Collection) (#$completelyDecidableCollection ?COL-3) (#$isa ?INS-3-A ?COL-3) (#$isa ?INS-3-B ?COL-3) (#$isa ?INS-3-C ?COL-3) (#$isa ?PRED #$BinaryPredicate) (?PRED ?INS-2-A ?INS-3-A) (?PRED ?INS-2-B ?INS-3-A) (?PRED ?INS-2-C ?INS-3-A) (?PRED ?INS-2-C ?INS-3-B) (?PRED ?INS-2-C ?INS-3-C)) (#$and (#$isa ?WHAT-2 ?COL-2) (#$isa ?WHAT-3 ?COL-3) (#$assertedSentence (?PRED ?WHAT-2 ?WHAT-3)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT-2 . ?INS-2-A) (?WHAT-3 . ?INS-3-A)) ((?WHAT-2 . ?INS-2-B) (?WHAT-3 . ?INS-3-A)) ((?WHAT-2 . ?INS-2-C) (?WHAT-3 . ?INS-3-A)) ((?WHAT-2 . ?INS-2-C) (?WHAT-3 . ?INS-3-B)) ((?WHAT-2 . ?INS-2-C) (?WHAT-3 . ?INS-3-C)))) :COMMENT "Test that opening a split link to an already good problem
  1052. doesn't cause the other split tactic(s) to be discarded, even if
  1053. the split link has a lookahead productivity of zero for some reason.
  1054. This was discovered by a rounding error, calling
  1055. number-of-children-for-productivity instead of
  1056. cost-for-productivity, which caused a split tactic to be
  1057. deemed a split-prune tactic since it had a 0 productivity,
  1058. even though it led to a good problem!  This was doubly fixed by
  1059. fixing the rounding error in addition to removing support for
  1060. split-prune tactics entirely, since this should now be subsumed
  1061. by strategic uninterestingness.")
  1062. ;;; Result(195)  <==== #<INFERENCE-UNIT-TEST 0>
  1063. ;;; CYC(196): (DEFINE-INFERENCE-UNIT-TEST :PROVE-NEGATION-VIA-RELATION-ALL-INSTANCE-AND-SINGLE-ENTRY :OWNER "pace" :WORKING? NIL :BUG 10753 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?INS-1 ?COL-1) (#$isa ?PRED #$BinaryPredicate) (#$arg2Format ?PRED #$SingleEntry) (#$relationAllInstance ?PRED ?COL-1 "the instance")) (#$not (?PRED ?INS-1 "chaff"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that via a #$relationAllInstance gaf and SingleEntry format
  1064. reasoning, we can conclude a negation.")
  1065. ;;; Result(196)  <==== #<INFERENCE-UNIT-TEST 0>
  1066. ;;; CYC(197): (DEFINE-INFERENCE-UNIT-TEST :CANT-PROVE-NEGATION-VIA-RELATION-ALL-INSTANCE-WITHOUT-SINGLE-ENTRY :OWNER "pace" :BUG 10753 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?INS-1 ?COL-1) (#$isa ?PRED #$BinaryPredicate) (#$relationAllInstance ?PRED ?COL-1 "the instance")) (#$not (?PRED ?INS-1 "chaff"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Like @xref :prove-negation-via-relation-all-instance-and-single-entry
  1067. except lacks the SingleEntry assumption, therefore it oughtn't
  1068. be able to prove the consequent.")
  1069. ;;; Result(197)  <==== #<INFERENCE-UNIT-TEST 0>
  1070. ;;; CYC(198): (DEFINE-INFERENCE-UNIT-TEST :PROVE-NEGATION-VIA-RELATION-ALL-INSTANCE-AND-INTERVAL-ENTRY :OWNER "pace" :WORKING? NIL :BUG 10754 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?INS-1 ?COL-1) (#$isa ?PRED #$BinaryPredicate) (#$arg2Format ?PRED #$IntervalEntry) (#$relationAllInstance ?PRED ?COL-1 (#$Unity 42 212))) (#$not (?PRED ?INS-1 (#$Unity 17)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that via a #$relationAllInstance gaf and IntervalEntry format
  1071. reasoning, we can conclude a negation.")
  1072. ;;; Result(198)  <==== #<INFERENCE-UNIT-TEST 0>
  1073. ;;; CYC(199): (DEFINE-INFERENCE-UNIT-TEST :CANT-PROVE-NEGATION-VIA-RELATION-ALL-INSTANCE-WITHOUT-INTERVAL-ENTRY :OWNER "pace" :BUG 10754 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL-1 #$Collection) (#$isa ?INS-1 ?COL-1) (#$isa ?PRED #$BinaryPredicate) (#$relationAllInstance ?PRED ?COL-1 (#$Unity 42 212))) (#$not (?PRED ?INS-1 (#$Unity 17)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Like @xref :prove-negation-via-relation-all-instance-and-interval-entry
  1074. except lacks the IntervalEntry assumption, therefore it oughtn't
  1075. be able to prove the consequent.")
  1076. ;;; Result(199)  <==== #<INFERENCE-UNIT-TEST 0>
  1077. ;;; CYC(200): (DEFINE-INFERENCE-UNIT-TEST :TRANSITIVITY-PLUS-GENLPREDS :OWNER "kknight" :WORKING? NIL :BUG 11172 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?SPEC-PRED #$TransitiveBinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$isa ?C #$Individual) (?SPEC-PRED ?A ?B) (?SPEC-PRED ?B ?C)) (?GENL-PRED ?A ?C)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that transitivity plays nicely with genlPreds,
  1078. even when the genlPred is not transitive.")
  1079. ;;; Result(200)  <==== #<INFERENCE-UNIT-TEST 0>
  1080. ;;; CYC(201): (DEFINE-INFERENCE-UNIT-TEST :NEGATIONPREDS :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-1 #$BinaryPredicate) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$negationPreds ?PRED-1 ?PRED-2) (?PRED-1 ?A ?B)) (#$not (?PRED-2 ?A ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a simple negationPreds lookup works.")
  1081. ;;; Result(201)  <==== #<INFERENCE-UNIT-TEST 0>
  1082. ;;; CYC(202): (DEFINE-INFERENCE-UNIT-TEST :NEGATIONPREDS-PLUS-SYMMETRY :OWNER "kknight" :BUG 11277 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-1 #$SymmetricBinaryPredicate) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$negationPreds ?PRED-1 ?PRED-2) (?PRED-1 ?A ?B)) (#$and (#$not (?PRED-2 ?A ?B)) (#$not (?PRED-2 ?B ?A)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that negationPreds lookup plays nicely with symmetry.")
  1083. ;;; Result(202)  <==== #<INFERENCE-UNIT-TEST 0>
  1084. ;;; CYC(203): (DEFINE-INFERENCE-UNIT-TEST :NEGATIONINVERSE :OWNER "kknight" :BUG 11280 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-1 #$BinaryPredicate) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$negationInverse ?PRED-1 ?PRED-2) (?PRED-1 ?A ?B)) (#$not (?PRED-2 ?B ?A))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a simple negationInverse lookup works.")
  1085. ;;; Result(203)  <==== #<INFERENCE-UNIT-TEST 0>
  1086. ;;; CYC(204): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHESIS-MTS-ARE-HIGHLY-RELEVANT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?A #$Individual) (#$thereExists ?ANTE (#$and (#$ist-Asserted ?ANTE (#$hypotheticalTerm ?A)) (#$highlyRelevantMt ?ANTE)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that the hypothesis mt for the query is highlyRelevant.")
  1087. ;;; Result(204)  <==== #<INFERENCE-UNIT-TEST 0>
  1088. ;;; CYC(205): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHESIS-MTS-ARE-NOT-HIGHLY-RELEVANT-EVERYWHERE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?A #$Individual) (#$thereExists ?ANTE (#$and (#$ist-Asserted ?ANTE (#$hypotheticalTerm ?A)) (#$highlyRelevantMt ?ANTE)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$implies (#$isa ?B #$Collection) (#$thereExists ?ANTE (#$and (#$ist-Asserted ?ANTE (#$hypotheticalTerm ?A)) (#$unknownSentence (#$highlyRelevantMt ?ANTE)))))) :PROPERTIES (:CONDITIONAL-SENTENCE? T) :EXPECTED-RESULT (NIL)))) :COMMENT "Ensure that the hypothesis mt for the query is not universally highlyRelevant.")
  1089. ;;; Result(205)  <==== #<INFERENCE-UNIT-TEST 0>
  1090. ;;; CYC(206): (DEFINE-INFERENCE-UNIT-TEST :KNOWN-SENTENCE-DOESNT-CRASH-ON-ILLFORMED-ASENT :OWNER "jantos" :BUG 11185 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Predicate) (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED ?COL)) (#$and (#$isa ?SOME-PRED ?COL) (#$knownSentence (?SOME-PRED #$Thing #$Thing ?WHAT)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that :removal-knownSentence-pos-gaf does not crash
  1091.    when a syntactically ill-formed atomic sentence is passed to it")
  1092. ;;; Result(206)  <==== #<INFERENCE-UNIT-TEST 0>
  1093. ;;; CYC(207): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-DOESNT-CRASH-ON-ILLFORMED-ASENT :OWNER "jantos" :BUG 11185 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Predicate) (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED ?COL)) (#$and (#$thereExists ?SOME-PRED (#$and (#$isa ?SOME-PRED ?COL) (#$unknownSentence (?SOME-PRED #$Thing #$Thing #$Thing)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that :removal-unknownSentence-pos-gaf does not crash
  1094.    when a syntactically ill-formed ground atomic sentence is passed to it.")
  1095. ;;; Result(207)  <==== #<INFERENCE-UNIT-TEST 0>
  1096. ;;; CYC(208): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-DOESNT-CRASH-ON-ILLFORMED-NON-ASENT :OWNER "goolsbey" :BUG 13341 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Predicate) (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED ?COL)) (#$and (#$thereExists ?SOME-PRED (#$and (#$isa ?SOME-PRED ?COL) (#$unknownSentence (#$thereExists ?VAL (?SOME-PRED ?VAL ?VAL ?VAL))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that :removal-unknown-sentence-check does not crash
  1097.    when a syntactically ill-formed closed, non-ground sentence is passed to it.")
  1098. ;;; Result(208)  <==== #<INFERENCE-UNIT-TEST 0>
  1099. ;;; CYC(209): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-UNEXHAUSTED :OWNER "goolsbey" :BUG 11608 :SENTENCE (QUOTE (#$ist #$BaseKB (#$unknownSentence (#$thereExists ?N (#$and (#$equalSymbols ?N 1) (#$trueSubL (#$ExpandSubLFn (?N) (PWHEN (= ?N 1) (WITH-INFERENCE-ERROR-HANDLING (ERROR "zyxwvut")))))))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "An #$unknownSentence recursive query that doesn't run to exhaustion should
  1100.    not be considered successful.")
  1101. ;;; Result(209)  <==== #<INFERENCE-UNIT-TEST 0>
  1102. ;;; CYC(210): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-ABORTED :OWNER "goolsbey" :BUG 11608 :SENTENCE (QUOTE (#$ist #$BaseKB (#$unknownSentence (#$thereExists ?N (#$and (#$equalSymbols ?N 1) (#$performSubL (#$ExpandSubLFn (?N) (PWHEN (= ?N 1) (QUERY-ABORT))))))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ABORT :KB :TINY :COMMENT "An #$unknownSentence recursive query that is aborted should cause all
  1103.    encompassing queries to abort as well.")
  1104. ;;; Result(210)  <==== #<INFERENCE-UNIT-TEST 0>
  1105. ;;; CYC(211): (DEFINE-INFERENCE-UNIT-TEST :INFERENCE-PSC-CONDITIONAL-QUERY :OWNER "goolsbey" :BUG 4514 :SENTENCE (QUOTE (#$ist #$InferencePSC (#$implies (#$isa ?X #$Individual) (#$evaluate ?MT (#$EvaluateSubLFn (#$SubLQuoteFn (CURRENT-MT-RELEVANCE-MT))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?MT . #$InferencePSC)))) :COMMENT "Conditional queries in #$InferencePSC should use #$InferencePSC as the query mt.")
  1106. ;;; Result(211)  <==== #<INFERENCE-UNIT-TEST 0>
  1107. ;;; CYC(212): (DEFINE-INFERENCE-UNIT-TEST :EVERYTHING-PSC-CONDITIONAL-QUERY :OWNER "goolsbey" :BUG 4514 :SENTENCE (QUOTE (#$ist #$EverythingPSC (#$implies (#$isa ?X #$Individual) (#$evaluate ?MT (#$EvaluateSubLFn (#$SubLQuoteFn (CURRENT-MT-RELEVANCE-MT))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?MT . #$EverythingPSC)))) :COMMENT "Conditional queries in #$EverythingPSC should use #$EverythingPSC as the query mt.")
  1108. ;;; Result(212)  <==== #<INFERENCE-UNIT-TEST 0>
  1109. ;;; CYC(213): (PWHEN-FEATURE :CYC-TIME (DEFINE-INFERENCE-UNIT-TEST :DAY-FN-INSTANCE-OF-DAY-OF-YEAR-FN :OWNER "goolsbey" :BUG 11081 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa (#$DayFn 1 (#$MonthFn #$May (#$YearFn 2002))) (#$DayOfYearFn #$May 1)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "DayFn should provably be an instance of DayOfYearFn") (DEFINE-INFERENCE-UNIT-TEST :DAY-FN-INSTANCE-OF-DAY-OF-MONTH-FN :OWNER "goolsbey" :BUG 11081 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa (#$DayFn 1 (#$MonthFn #$May (#$YearFn 2002))) (#$DayOfMonthFn 1)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "DayFn should provably be an instance of DayOfMonthFn"))
  1110. ;;; Result(213)  <==== #<INFERENCE-UNIT-TEST 0>
  1111. ;;; CYC(214): (DEFINE-INFERENCE-UNIT-TEST :THE-SET-OF-ELEMENTS-RETURNS-HL-NARTS :OWNER "jantos" :BUG 11518 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?COL #$Collection) (#$isa ?RCOL #$Collection) (#$arg1Isa ?FUNC ?COL) (#$resultIsa ?FUNC ?RCOL) (#$isa ?TERM ?COL) (?PRED (?FUNC ?TERM))) (#$and (?SOME-PRED ?WHAT) (#$elementOf ?WHAT (#$TheSetOf ?X (#$isa ?X ?RCOL))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT ?FUNC ?TERM) (?SOME-PRED . ?PRED)))) :COMMENT "the-set-of-elements should return the narts instead of the nart-formula when called from :removal-elementof-thesetof-unify.  Since not all of the other removal modules nartify the bindings, only when the result is nart, these removal modules would be able to use the indexing to return answers.")
  1112. ;;; Result(214)  <==== #<INFERENCE-UNIT-TEST 0>
  1113. ;;; CYC(215): (DEFINE-INFERENCE-UNIT-TEST :THE-COLLECTION-OF-INSTANCES-RETURNS-HL-NARTS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?COL #$Collection) (#$isa ?RCOL #$Collection) (#$arg1Isa ?FUNC ?COL) (#$resultIsa ?FUNC ?RCOL) (#$isa ?TERM ?COL) (?PRED (?FUNC ?TERM))) (#$and (?SOME-PRED ?WHAT) (#$isa ?WHAT (#$TheCollectionOf ?X (#$isa ?X ?RCOL))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT ?FUNC ?TERM) (?SOME-PRED . ?PRED)))) :COMMENT ":removal-isa-TheCollectionOf-unify should return the narts instead of the nart-formulas.  Since not all of the other removal modules nartify the bindings, only when the result is nart, these removal modules would be able to use the indexing to return answers.")
  1114. ;;; Result(215)  <==== #<INFERENCE-UNIT-TEST 0>
  1115. ;;; CYC(216): (DEFINE-INFERENCE-UNIT-TEST :FIND-VISIBLE-ASSERTIONS-IN-INFERENCEPSC :OWNER "jantos" :BUG 11759 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?TERM ?COL)) (#$thereExists ?ASSERTION (#$and (#$evaluate ?ASSERTION (#$EvaluateSubLFn (#$ExpandSubLFn (?TERM ?COL) (FIRST (FIND-VISIBLE-ASSERTIONS-CYCL (QUOTE (#$isa ?TERM ?COL)) #$InferencePSC))))) (#$quotedIsa ?ASSERTION #$CycLAssertion)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "find-visible-assertions-cycl in #$InferencePSC or #$EverythingPSC should find assertion asserted in its genl mt (i.e. any other mt)")
  1116. ;;; Result(216)  <==== #<INFERENCE-UNIT-TEST 0>
  1117. ;;; CYC(217): (DEFINE-INFERENCE-UNIT-TEST :NEAREST-ISA-OF-TYPE :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?TYPE #$Collection) (#$isa ?OTHER-COL #$Collection) (#$genls ?COL ?OTHER-COL) (#$isa ?COL ?TYPE) (#$isa ?OTHER-COL ?TYPE) (#$isa ?TERM ?COL)) (#$nearestIsaOfType ?TERM ?TYPE ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL)))) :KB :FULL :COMMENT "Ensure that we pick only the nearest isa of the give type.")
  1118. ;;; Result(217)  <==== #<INFERENCE-UNIT-TEST 0>
  1119. ;;; CYC(218): (DEFINE-INFERENCE-UNIT-TEST :NEAREST-GENLS-OF-TYPE :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL1 #$Collection) (#$isa ?COL2 #$Collection) (#$isa ?TYPE #$Collection) (#$isa ?OTHER-COL #$Collection) (#$genls ?COL1 ?COL2) (#$genls ?COL2 ?OTHER-COL) (#$isa ?COL2 ?TYPE) (#$isa ?OTHER-COL ?TYPE)) (#$nearestGenlsOfType ?COL1 ?TYPE ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL2)))) :KB :FULL :COMMENT "Ensure that we pick only the nearest genls of the give type.")
  1120. ;;; Result(218)  <==== #<INFERENCE-UNIT-TEST 0>
  1121. ;;; CYC(219): (DEFINE-INFERENCE-UNIT-TEST :CHOOSE-RIGHT-GROSSLY-INCOMPLETE-ISA :OWNER "pace" :BUG 11868 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Collection) (#$isa ?INS ?COL) (#$relationExistsAll #$isa #$Predicate ?COL)) (#$and (#$isa ?WHAT ?COL) (#$isa ?WHAT #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 1000 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?INS)))) :KB :TINY :COMMENT "Don't choose the (#$isa ?WHAT #$Collection) literal.  It used to look tasty because
  1122. it had two tactics -- a :removal-relation-exists-all-unify tactic with productivity 0,
  1123. and a big fat :removal-all-instances tactic that didn't count because it exceeded the
  1124. productivity limit.  We disabled the combination of #$isa and :removal-relation-exists-all-unify
  1125. to make this unit test succeed.  Now it ought to choose the (#$isa ?WHAT ?COL) literal instead.")
  1126. ;;; Result(219)  <==== #<INFERENCE-UNIT-TEST 0>
  1127. ;;; CYC(220): (DEFINE-INFERENCE-UNIT-TEST :MT-UNION-FN-GENL-MT-SIMPLE :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT1 #$Microtheory) (#$isa ?MT2 #$Microtheory)) (#$and (#$genlMt (#$MtUnionFn ?MT1 ?MT2) ?MT1) (#$genlMt (#$MtUnionFn ?MT1 ?MT2) ?MT2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Ensure that (genlMt (MtUnionFn A B) A) and (genlMt (MtUnionFn A B) B)")
  1128. ;;; Result(220)  <==== #<INFERENCE-UNIT-TEST 0>
  1129. ;;; CYC(221): (DEFINE-INFERENCE-UNIT-TEST :MT-UNION-FN-GENL-MT-REFLEXIVE :OWNER "kknight" :WORKING? NIL :BUG 11965 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT1 #$Microtheory) (#$isa ?MT2 #$Microtheory)) (#$genlMt (#$MtUnionFn ?MT1 ?MT2) (#$MtUnionFn ?MT1 ?MT2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Ensure that (genlMt (MtUnionFn A B) (MtUnionFn A B))")
  1130. ;;; Result(221)  <==== #<INFERENCE-UNIT-TEST 0>
  1131. ;;; CYC(222): (DEFINE-INFERENCE-UNIT-TEST :MT-UNION-FN-GENL-MT-COMMUTATIVE :OWNER "kknight" :WORKING? NIL :BUG 11965 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT1 #$Microtheory) (#$isa ?MT2 #$Microtheory)) (#$genlMt (#$MtUnionFn ?MT1 ?MT2) (#$MtUnionFn ?MT2 ?MT1))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Ensure that (genlMt (MtUnionFn A B) (MtUnionFn B A))")
  1132. ;;; Result(222)  <==== #<INFERENCE-UNIT-TEST 0>
  1133. ;;; CYC(223): (DEFINE-INFERENCE-UNIT-TEST :MT-UNION-FN-GENL-MT-GENERATE :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT1 #$Microtheory) (#$isa ?MT2 #$Microtheory) (#$isa ?MT3 #$Microtheory) (#$isa ?MT4 #$Microtheory) (#$genlMt ?MT1 ?MT3) (#$genlMt ?MT2 ?MT4)) (#$genlMt (#$MtUnionFn ?MT1 ?MT2) ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT-TEST (QUOTE EQUALS-EL?) :EXPECTED-RESULT (QUOTE (((?WHAT . ?MT1)) ((?WHAT . ?MT2)) ((?WHAT . ?MT3)) ((?WHAT . ?MT4)) ((?WHAT #$MtUnionFn ?MT1 ?MT2)) ((?WHAT . #$CycAgencyTheoryMt)) ((?WHAT . #$UniversalVocabularyImplementationMt)) ((?WHAT . #$LogicalTruthMt)) ((?WHAT . #$LogicalTruthImplementationMt)) ((?WHAT . #$CoreCycLImplementationMt)) ((?WHAT . #$CoreCycLMt)) ((?WHAT . #$UniversalVocabularyMt)) ((?WHAT . #$CycHistoricalPossibilityTheoryMt)) ((?WHAT . #$BaseKB)))) :KB :FULL :COMMENT "Ensure that (genlMt (MtUnionFn A B) ?WHAT) generates the correct Mts")
  1134. ;;; Result(223)  <==== #<INFERENCE-UNIT-TEST 0>
  1135. ;;; CYC(224): (DEFINE-INFERENCE-UNIT-TEST :CONDITIONAL-QUERY-EXTENT-CACHED-CLOSED-QUERY-FN :OWNER "goolsbey" :BUG 12427 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P ?X)) (#$queryExtentCached (#$QueryFn (#$Quote (?P 212)) (#$TheSet (#$TheList #$InferenceMaxTransformationStepsParameter 1))))) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :KB :FULL :COMMENT "Ensure that #$queryExtentCached correctly caches the results of evaluating a
  1136.    closed #$QueryFn term in the hypothesis mt.")
  1137. ;;; Result(224)  <==== #<INFERENCE-UNIT-TEST 0>
  1138. ;;; CYC(225): (DEFINE-INFERENCE-UNIT-TEST :CONDITIONAL-QUERY-EXTENT-CACHED-PREDICATE-QUERY-FN :OWNER "goolsbey" :BUG 12427 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P ?X)) (#$queryExtentCached (#$PredicateQueryFn (#$Kappa (?X) (?P ?X)) (#$TheSet (#$TheList #$InferenceMaxTransformationStepsParameter 1))))) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :KB :FULL :COMMENT "Ensure that #$queryExtentCached correctly caches the results of evaluating a
  1139.    #$PredicateQueryFn #$Kappa term in the hypothesis mt.")
  1140. ;;; Result(225)  <==== #<INFERENCE-UNIT-TEST 0>
  1141. ;;; CYC(226): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-ALL-ISA-OF-TYPE-1 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?COL (#$and (#$isa #$May ?COL) (#$isa ?COL #$SiblingDisjointCollectionType))))) :PROPERTIES (QUOTE (:ALLOWED-MODULES (:NOT (:OR :REMOVAL-ALL-ISA :REMOVAL-ALL-INSTANCES)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "should be a conjunctive removal unit test")
  1142. ;;; Result(226)  <==== #<INFERENCE-UNIT-TEST 0>
  1143. ;;; CYC(227): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-ALL-ISA-OF-TYPE-2 :OWNER "goolsbey" :BUG 12752 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TYPE-COL #$Collection) (#$genls ?TYPE-COL #$Collection) (#$completelyEnumerableCollection ?TYPE-COL) (#$isa ?TERM ?COL) (#$isa ?COL ?TYPE-COL)) (#$and (#$isa ?TERM ?WHAT) (#$isa ?WHAT ?TYPE-COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (ZEROP (PROBLEM-EXECUTED-TACTIC-COUNT (FIND-PREVIOUS-INFERENCE-PROBLEM-BY-EL-ASENT (QUOTE (#$isa ?VAR0 ?TYPE-COL)))))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :KB :TINY :COMMENT "Since ?TYPE-COL is completely enumerable, the conjunctive removal for the
  1144.    entire conjunction should also be complete.  Therefore, we shouldn't have
  1145.    to do any of the single-literal removals.")
  1146. ;;; Result(227)  <==== #<INFERENCE-UNIT-TEST 0>
  1147. ;;; CYC(228): (DEFINE-INFERENCE-UNIT-TEST :IST-VAR-VAR-IMPOSSIBLE :BUG 12826 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$ist ?X ?Y))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "Verify that a query of the form (#$ist ?X ?Y) fails quickly with no error.")
  1148. ;;; Result(228)  <==== #<INFERENCE-UNIT-TEST 0>
  1149. ;;; CYC(229): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-EXISTENTIAL-QUERY-UNIQUE-WRT-BINDINGS-HALTS-EAGERLY :BUG 12878 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$thereExists ?N (#$integerBetween 1 ?N 2)))) :PROPERTIES (QUOTE (:RESULT-UNIQUENESS :BINDINGS :MAX-PROBLEM-COUNT 3 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "A closed existential query that only generates answers
  1150.    unique wrt bindings can halt as soon as an answer is generated.
  1151.    Consequently, it should only have to generate 2 problems, not 3.")
  1152. ;;; Result(229)  <==== #<INFERENCE-UNIT-TEST 0>
  1153. ;;; CYC(230): (DEFINE-INFERENCE-UNIT-TEST :TOP-LEVEL-REMOVALS-ARE-NOT-NEW-ROOTS :OWNER "goolsbey" :BUG 13146 :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 1 ?X 3)))) :PROPERTIES (QUOTE (:MAX-NUMBER 1 :MAX-PROBLEM-COUNT 6 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :ALLOWED-MODULES (:NOT :JOIN) :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "The first #$integerBetween iteration should not generate (integerBetween 1 1 3)
  1154.    as a new root.  If so, it would erroneously continue the iteration, generating
  1155.    more problems than necessary.  This new problem would only be considered a new root
  1156.    if we gave T to the answer link, which is unwarranted in a removal-only ask.")
  1157. ;;; Result(230)  <==== #<INFERENCE-UNIT-TEST 0>
  1158. ;;; CYC(231): (DEFINE-INFERENCE-UNIT-TEST :ITERATIVITY-NON-CONTINUABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 1000000) (#$quotedIsa ?X #$SubLInteger)))) :PROPERTIES (QUOTE (:MAX-NUMBER 1 :PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :MAX-TIME 1 :CONTINUABLE? NIL)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Ensure that it tests the first one before exhaustively iterating over the generator.")
  1159. ;;; Result(231)  <==== #<INFERENCE-UNIT-TEST 0>
  1160. ;;; CYC(232): (DEFINE-INFERENCE-UNIT-TEST :ITERATIVITY-CONTINUABLE :OWNER "pace" :BUG 13146 :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 1000000) (#$quotedIsa ?X #$SubLInteger)))) :PROPERTIES (QUOTE (:MAX-NUMBER 1 :PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :MAX-TIME 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Ensure that it tests the first one before exhaustively iterating over the generator.")
  1161. ;;; Result(232)  <==== #<INFERENCE-UNIT-TEST 0>
  1162. ;;; CYC(233): (DEFINE-INFERENCE-UNIT-TEST :GENLPREDS-LOOKUP-GENERATES-CORRECT-SUPPORTS :OWNER "jantos" :BUG 12997 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GPRED #$UnaryPredicate) (#$isa ?SPRED #$UnaryPredicate) (#$isa ?CPRED #$UnaryPredicate) (#$genlPreds ?SPRED ?GPRED) (#$isa ?TERM #$Thing) (?SPRED ?TERM) (#$implies (?GPRED ?EXPND) (?CPRED ?EXPND)) (#$assertionDirection (#$implies (?GPRED ?EXPND) (?CPRED ?EXPND)) #$Forward-AssertionDirection)) (?CPRED ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "@todo write this")
  1163. ;;; Result(233)  <==== #<INFERENCE-UNIT-TEST 0>
  1164. ;;; CYC(234): (DEFINE-INFERENCE-UNIT-TEST :IGNORE-SUBSUMED-CONNECTED-CONJUNCTION-TACTICS :OWNER "kknight" :BUG 13037 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?HIGH #$Collection) (#$genls ?HIGH #$Individual) (#$isa ?MED #$Collection) (#$genls ?MED ?HIGH) (#$isa ?LOW #$Collection) (#$genls ?LOW ?MED) (#$isa ?PRED #$UnaryPredicate) (?PRED ?MED) (?PRED 1) (?PRED 2) (?PRED 3) (?PRED 4)) (#$and (#$genls ?LOW ?M) (#$genls ?M ?HIGH) (?PRED ?M))))) :EXPECTED-RESULT (QUOTE (((?M . ?MED)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :BROWSABLE? T)) :FOLLOWUPS (QUOTE ((:SENTENCE (#$trueSubL (#$SubLQuoteFn (CLET ((ROOT-PROBLEM (PREVIOUS-QUERY-ROOT-PROBLEM))) (= 1 (PROBLEM-EXECUTED-TACTIC-COUNT ROOT-PROBLEM))))) :EXPECTED-RESULT (NIL)))) :KB :TINY :COMMENT "A conjunctive removal should suggest handling A^B.
  1165.    Therefore, we probably shouldn't attempt to handle A or B individually.")
  1166. ;;; Result(234)  <==== #<INFERENCE-UNIT-TEST 0>
  1167. ;;; CYC(235): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-RELATION-ALL-INSTANCE-ITERATE-NAUT-FAILURE :OWNER "jantos" :BUG 14285 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL-1 #$Collection) (#$genls ?COL-1 #$Individual) (#$isa ?COL-2 #$Collection) (#$genls ?COL-2 #$Individual) (#$genls ?COL-2 ?COL-1) (#$isa ?TERM-1 ?COL-2) (#$isa ?TERM-2 #$Thing) (#$relationAllInstance ?PRED ?COL-1 ?TERM-2)) (#$and (?PRED (#$TheSet ?WHAT) ?TERM-2) (#$equalSymbols ?WHAT ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :KB :TINY :COMMENT "Verify that :REMOVAL-RELATION-ALL-INSTANCE-ITERATE
  1168.    doesn't error on the open NAUT.")
  1169. ;;; Result(235)  <==== #<INFERENCE-UNIT-TEST 0>
  1170. ;;; CYC(236): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-RELATION-INSTANCE-ALL-ITERATE-NAUT-FAILURE :OWNER "jantos" :BUG 14285 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL-1 #$Collection) (#$genls ?COL-1 #$Individual) (#$isa ?COL-2 #$Collection) (#$genls ?COL-2 #$Individual) (#$genls ?COL-2 ?COL-1) (#$isa ?TERM-1 ?COL-2) (#$isa ?TERM-2 #$Thing) (#$relationInstanceAll ?PRED ?TERM-2 ?COL-1)) (#$and (?PRED ?TERM-2 (#$TheSet ?WHAT)) (#$equalSymbols ?WHAT ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :KB :TINY :COMMENT "Verify that :REMOVAL-RELATION-INSTANCE-ALL-ITERATE
  1171.    doesn't error on the open NAUT.")
  1172. ;;; Result(236)  <==== #<INFERENCE-UNIT-TEST 0>
  1173. ;;; CYC(237): (DEFINE-INFERENCE-UNIT-TEST :NEW-TERMS-ALLOWED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL #$Collection) (#$relationInstanceExists ?PRED 212 ?COL)) (#$thereExists ?Y (?PRED 212 ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? T :NEW-TERMS-ALLOWED? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that if new terms are allowed, we get 'em.")
  1174. ;;; Result(237)  <==== #<INFERENCE-UNIT-TEST 0>
  1175. ;;; CYC(238): (DEFINE-INFERENCE-UNIT-TEST :NEW-TERMS-DISALLOWED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?COL #$Collection) (#$relationInstanceExists ?PRED 212 ?COL)) (#$thereExists ?Y (?PRED 212 ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? T :NEW-TERMS-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that if new terms are disallowed, we don't get 'em.
  1176. This differs from :new-terms-allowed solely in the setting of :new-terms-allowed? and the expected result.")
  1177. ;;; Result(238)  <==== #<INFERENCE-UNIT-TEST 0>
  1178. ;;; CYC(239): (DEFINE-INFERENCE-UNIT-TEST :PAD-INITIALIZED? :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PAD-TABLE-INITIALIZED?))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "If this doesn't work, none of the following PAD tests will work.")
  1179. ;;; Result(239)  <==== #<INFERENCE-UNIT-TEST 0>
  1180. ;;; CYC(240): (DEFINE-INFERENCE-UNIT-TEST :VERY-LOW-PAD :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 1000) (#$integerBetween -1000 ?X -1)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :PROBABLY-APPROXIMATELY-DONE 0.5d0)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :PROBABLY-APPROXIMATELY-DONE :COMMENT "Test that a very low PAD cutoff halts quickly.")
  1181. ;;; Result(240)  <==== #<INFERENCE-UNIT-TEST 0>
  1182. ;;; CYC(241): (DEFINE-INFERENCE-UNIT-TEST :PAD-DOESNT-AFFECT-ANSWERABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 10000) (#$integerBetween 1 ?X 10000)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :PROBABLY-APPROXIMATELY-DONE 0.5d0)) :EXPECTED-RESULT-TEST (QUOTE LENGTH>=) :EXPECTED-RESULT 1 :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that unanswerable-PAD doesn't kick in once an answer has been generated.")
  1183. ;;; Result(241)  <==== #<INFERENCE-UNIT-TEST 0>
  1184. ;;; CYC(242): (DEFINE-INFERENCE-UNIT-TEST :EXHAUSTIVE-PAD :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 1000) (#$integerBetween -1000 ?X -1)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :PROBABLY-APPROXIMATELY-DONE 1)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a PAD of 1 (100%) causes the query to run to exhaustion.")
  1185. ;;; Result(242)  <==== #<INFERENCE-UNIT-TEST 0>
  1186. ;;; CYC(243): (DEFINE-INFERENCE-UNIT-TEST :EXHAUSTIVE-REAL-PAD :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 1000) (#$integerBetween -1000 ?X -1)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :PROBABLY-APPROXIMATELY-DONE 1.0d0)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a PAD of 1.0 (100%) causes the query to run to exhaustion.")
  1187. ;;; Result(243)  <==== #<INFERENCE-UNIT-TEST 0>
  1188. ;;; CYC(244): (DEFINE-INFERENCE-UNIT-TEST :PAD-CONTINUATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 100000) (#$integerBetween -100000 ?X -1)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-PROBLEM-COUNT :POSITIVE-INFINITY :PROBABLY-APPROXIMATELY-DONE 0.95d0 :MAX-TIME 30 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :PROBABLY-APPROXIMATELY-DONE :FOLLOWUPS (QUOTE ((:PROPERTIES (:MAX-TIME 2 :PROBABLY-APPROXIMATELY-DONE 0.1d0 :CONTINUABLE? T) :EXPECTED-HALT-REASON :PROBABLY-APPROXIMATELY-DONE) (:PROPERTIES (:MAX-TIME 2 :PROBABLY-APPROXIMATELY-DONE 0.951d0 :CONTINUABLE? T) :EXPECTED-HALT-REASON :PROBABLY-APPROXIMATELY-DONE) (:PROPERTIES (:MAX-TIME 2 :PROBABLY-APPROXIMATELY-DONE 0.999d0 :CONTINUABLE? NIL) :EXPECTED-HALT-REASON :MAX-TIME))) :COMMENT "Test that continuing with a higher PAD takes the previous work into account,
  1189. and that continuing with a lower PAD terminates instantly.")
  1190. ;;; Result(244)  <==== #<INFERENCE-UNIT-TEST 0>
  1191. ;;; CYC(245): (DEFINE-INFERENCE-UNIT-TEST :KAPPA-REMOVAL-WORKS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?PERS #$Individual) ((#$Kappa (?X ?Y) (#$isa ?X ?Y)) ?PERS #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? T :NEW-TERMS-ALLOWED? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that removal-kappa-expand is called when we use a kappa expression.")
  1192. ;;; Result(245)  <==== #<INFERENCE-UNIT-TEST 0>
  1193. ;;; CYC(246): (DEFINE-INFERENCE-UNIT-TEST :DISJUNCTIVE-EXISTENTIALS-WITH-SAME-NAME :OWNER "jantos" :CREATOR "pace" :BUG 13837 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?BIN-PRED #$BinaryPredicate) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$isa ?UNARY-PRED #$UnaryPredicate)) (#$thereExists ?Y (#$and (#$or (#$isa #$Thing #$Thing) (#$thereExists ?X (?UNARY-PRED ?X))) (#$or (#$isa #$Thing #$Thing) (#$thereExists ?X (?BIN-PRED ?X (?FUNC ?Y))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that disjunctions of existentials where the existential
  1194.   variable name is the same canonicalize correctly.")
  1195. ;;; Result(246)  <==== #<INFERENCE-UNIT-TEST 0>
  1196. ;;; CYC(247): (DEFINE-INFERENCE-UNIT-TEST :DONT-REOPEN-ANSWER-LINK :OWNER "goolsbey" :BUG 14740 :SENTENCE (QUOTE (#$ist #$BaseKB (#$isa 212 #$Integer))) :PROPERTIES (QUOTE (:CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$evaluate ?COUNT (#$EvaluateSubLFn (#$SubLQuoteFn (CLET ((INFERENCE (PREVIOUS-QUERY-INFERENCE)) (ANSWER (FIND-INFERENCE-ANSWER-BY-ID INFERENCE 0)) (JUSTIFICATION (FIRST (INFERENCE-ANSWER-JUSTIFICATIONS ANSWER))) (PROOFS (INFERENCE-ANSWER-JUSTIFICATION-PROOFS JUSTIFICATION))) (LENGTH PROOFS)))))) :EXPECTED-RESULT (((?COUNT . 1))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that the answer link is not reopened wrt T after it's closed
  1197.    once it gets its first answer wrt R.  This used to happen, resulting in
  1198.    bubbling up the removal proof to the inference a second time.")
  1199. ;;; Result(247)  <==== #<INFERENCE-UNIT-TEST 0>
  1200. ;;; CYC(248): (DEFINE-INFERENCE-UNIT-TEST :FIND-FREE-VARIABLE-OF-BOUND-EXISTENTIAL :OWNER "jantos" :BUG 14528 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Thing) (#$isa ?METAPRED #$UnaryPredicate) (#$arg1QuotedIsa ?METAPRED #$CycLAssertion) (#$thereExistExactly 212 ?X (?PRED ?X)) (?METAPRED (#$thereExistExactly 212 ?X (?PRED ?X)))) (?METAPRED (#$thereExistExactly ?N ?X (?PRED ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?N . 212)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "Bug 14528 revealed a bug where free variables in bound existential sentences were not being found.")
  1201. ;;; Result(248)  <==== #<INFERENCE-UNIT-TEST 0>
  1202. ;;; CYC(249): (DEFINE-INFERENCE-UNIT-TEST :THERE-EXISTS-VIA-RELATION-INSTANCE-EXISTS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM #$Individual) (#$relationInstanceExists ?PRED ?TERM #$Individual)) (#$thereExists ?VALUE (?PRED ?TERM ?VALUE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :relation-instance-exists-check-via-exemplar
  1203.    @todo add more")
  1204. ;;; Result(249)  <==== #<INFERENCE-UNIT-TEST 0>
  1205. ;;; CYC(250): (DEFINE-INFERENCE-UNIT-TEST :THERE-EXISTS-VIA-RELATION-EXISTS-INSTANCE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM #$Individual) (#$relationExistsInstance ?PRED #$Individual ?TERM)) (#$thereExists ?VALUE (?PRED ?VALUE ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :relation-exists-instance-check-via-exemplar
  1206.    @todo add more")
  1207. ;;; Result(250)  <==== #<INFERENCE-UNIT-TEST 0>
  1208. ;;; CYC(251): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-EXISTS-CHECK-VIA-EXEMPLAR :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM #$Individual) (#$isa ?VALUE #$Individual) (?PRED ?TERM ?VALUE)) (#$relationInstanceExists ?PRED ?TERM #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :there-exists-via-relation-instance-exists
  1209.    @todo add more")
  1210. ;;; Result(251)  <==== #<INFERENCE-UNIT-TEST 0>
  1211. ;;; CYC(252): (DEFINE-INFERENCE-UNIT-TEST :THERE-EXISTS-VIA-RELATION-INSTANCE-EXISTS-GENLPREDS :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?TERM #$Individual) (#$relationInstanceExists ?SPEC-PRED ?TERM #$Individual)) (#$thereExists ?VALUE (?GENL-PRED ?TERM ?VALUE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :relation-instance-exists-genlPreds-check-via-exemplar
  1212.    @todo add more")
  1213. ;;; Result(252)  <==== #<INFERENCE-UNIT-TEST 0>
  1214. ;;; CYC(253): (DEFINE-INFERENCE-UNIT-TEST :THERE-EXISTS-VIA-RELATION-EXISTS-INSTANCE-GENLPREDS :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?TERM #$Individual) (#$relationExistsInstance ?SPEC-PRED #$Individual ?TERM)) (#$thereExists ?VALUE (?GENL-PRED ?VALUE ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :relation-exists-instance-genlPreds-check-via-exemplar
  1215.    @todo add more")
  1216. ;;; Result(253)  <==== #<INFERENCE-UNIT-TEST 0>
  1217. ;;; CYC(254): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-EXISTS-GENLPREDS-CHECK-VIA-EXEMPLAR :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?TERM #$Individual) (#$isa ?VALUE #$Individual) (?SPEC-PRED ?TERM ?VALUE)) (#$relationInstanceExists ?GENL-PRED ?TERM #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :there-exists-via-relation-instance-exists-genlPreds
  1218.    @todo add more")
  1219. ;;; Result(254)  <==== #<INFERENCE-UNIT-TEST 0>
  1220. ;;; CYC(255): (DEFINE-INFERENCE-UNIT-TEST :THERE-EXISTS-VIA-RELATION-INSTANCE-EXISTS-GENLINVERSE :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlInverse ?SPEC-PRED ?GENL-PRED) (#$isa ?TERM #$Individual) (#$relationInstanceExists ?SPEC-PRED ?TERM #$Individual)) (#$thereExists ?VALUE (?GENL-PRED ?VALUE ?TERM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :relation-instance-exists-genlInverse-check-via-exemplar
  1221.    @todo add more")
  1222. ;;; Result(255)  <==== #<INFERENCE-UNIT-TEST 0>
  1223. ;;; CYC(256): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-EXISTS-GENLINVERSE-CHECK-VIA-EXEMPLAR :OWNER "goolsbey" :BUG 15286 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$isa ?TERM #$Individual) (#$isa ?VALUE #$Individual) (#$genlInverse ?SPEC-PRED ?GENL-PRED) (?SPEC-PRED ?VALUE ?TERM)) (#$relationInstanceExists ?GENL-PRED ?TERM #$Individual)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "dual of :there-exists-via-relation-instance-exists-genlInverse
  1224.    @todo add more")
  1225. ;;; Result(256)  <==== #<INFERENCE-UNIT-TEST 0>
  1226. ;;; CYC(257): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-EXISTS-EXPANSION-CLOSED :OWNER "kknight" :BUG 19803 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?SPEC-COL #$Collection) (#$isa ?GENL-COL #$Collection) (#$genls ?SPEC-COL ?GENL-COL) (#$isa ?TERM #$Individual) (#$relationInstanceExists ?SPEC-PRED ?TERM ?SPEC-COL)) (#$thereExists ?X (#$and (#$isa ?X ?GENL-COL) (?GENL-PRED ?TERM ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "check that we can ask the expansion of relationInstanceExists")
  1227. ;;; Result(257)  <==== #<INFERENCE-UNIT-TEST 0>
  1228. ;;; CYC(258): (DEFINE-INFERENCE-UNIT-TEST :RELATION-INSTANCE-EXISTS-EXPANSION-OPEN :OWNER "kknight" :BUG 19803 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?SPEC-COL #$Collection) (#$isa ?GENL-COL #$Collection) (#$genls ?SPEC-COL ?GENL-COL) (#$isa ?TERM #$Individual) (#$relationInstanceExists ?SPEC-PRED ?TERM ?SPEC-COL)) (#$thereExists ?X (#$and (#$isa ?X ?GENL-COL) (?GENL-PRED ?Y ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?Y . ?TERM)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "check that we can ask the expansion of relationInstanceExists")
  1229. ;;; Result(258)  <==== #<INFERENCE-UNIT-TEST 0>
  1230. ;;; CYC(259): (DEFINE-INFERENCE-UNIT-TEST :AVOID-LOOKUP-ON-INDETERMINATES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TERM-A #$Individual) (#$isa ?TERM-B #$Individual) (#$isa ?COMMON #$Individual) (#$isa ?CHAFF #$Individual) (#$relationInstanceExists ?PRED ?TERM-A #$Individual) (#$relationInstanceExists ?PRED ?TERM-B #$Individual) (?PRED ?TERM-A ?COMMON) (?PRED ?TERM-B ?COMMON) (?PRED ?TERM-B ?CHAFF)) (#$and (?PRED ?TERM-A ?WHAT) (?PRED ?TERM-B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :ALLOWED-MODULES (:NOT :JOIN) :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COMMON)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$evaluate ?COUNT (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (REMOVE :REMOVAL-RELATION-INSTANCE-EXISTS-PRUNE (PROBLEM-EXECUTED-TACTICS (FIND-PREVIOUS-INFERENCE-PROBLEM-BY-EL-ASENT (QUOTE (?PRED ?TERM-B (#$RelationInstanceExistsFn ?PRED ?TERM-A #$Individual))))) (FUNCTION EQ) (FUNCTION TACTIC-HL-MODULE-NAME))))))) :EXPECTED-RESULT (((?COUNT . 0))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "verify that the rIE statements don't cause distraction")
  1231. ;;; Result(259)  <==== #<INFERENCE-UNIT-TEST 0>
  1232. ;;; CYC(260): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-TRUE-SENTENCE-UNIVERSAL-DISJUNCTION-14A :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$forAll ?SPEC (#$forAll ?GENL (#$forAll ?X (#$implies (#$and (#$isa ?SPEC #$Collection) (#$isa ?GENL #$Collection) (#$genls ?SPEC ?GENL) (#$isa ?X ?SPEC)) (#$isa ?X ?GENL))))))) :KB :TINY :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "modeled on the removal module test
  1233. :removal-true-sentence-universal-disjunction 14")
  1234. ;;; Result(260)  <==== #<INFERENCE-UNIT-TEST 0>
  1235. ;;; CYC(261): (DEFINE-INFERENCE-UNIT-TEST :REMOVAL-TRUE-SENTENCE-UNIVERSAL-DISJUNCTION-14B :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$forAll ?SPEC (#$forAll ?GENL (#$forAll ?X (#$implies (#$and (#$isa ?SPEC #$Collection) (#$isa ?GENL #$Collection) (#$genls ?GENL ?SPEC) (#$isa ?X ?SPEC)) (#$isa ?X ?GENL))))))) :KB :TINY :EXPECTED-RESULT NIL :COMMENT "Just like :removal-true-sentence-universal-disjunction-14a
  1236. except reverses ?SPEC and ?GENL in the genls assertion,
  1237. so this one ought to fail.")
  1238. ;;; Result(261)  <==== #<INFERENCE-UNIT-TEST 0>
  1239. ;;; CYC(262): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-ASENT-WITH-3-CHILDREN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL #$BinaryPredicate) (#$isa ?SPEC #$BinaryPredicate) (#$isa ?INV #$BinaryPredicate) (#$genlPreds ?SPEC ?GENL) (#$genlInverse ?INV ?SPEC) (?GENL 1 2) (?SPEC 1 2) (?INV 2 1)) (#$ist #$InferencePSC (?GENL 1 2))))) :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-RESULT 3 :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RESULT-UNIQUENESS :PROOF :RETURN :BINDINGS-AND-SUPPORTS)) :COMMENT "Show that it's non unreasonable for a closed query
  1240.    to have a productivity of at least 3.")
  1241. ;;; Result(262)  <==== #<INFERENCE-UNIT-TEST 0>
  1242. ;;; CYC(263): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-KNOWN-SENTENCE-OF-ASENT-WITH-3-CHILDREN :OWNER "goolsbey" :BUG 16412 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL #$BinaryPredicate) (#$isa ?SPEC #$BinaryPredicate) (#$isa ?INV #$BinaryPredicate) (#$genlPreds ?SPEC ?GENL) (#$genlInverse ?INV ?SPEC) (?GENL 1 2) (?SPEC 1 2) (?INV 2 1)) (#$knownSentence (?GENL 1 2))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "The knownSentence HL module should not lie about
  1243.    the expected cost of this module being more than 2.")
  1244. ;;; Result(263)  <==== #<INFERENCE-UNIT-TEST 0>
  1245. ;;; CYC(264): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-KNOWN-SENTENCE-OF-IST-ASENT-WITH-3-CHILDREN :OWNER "goolsbey" :BUG 16413 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL #$BinaryPredicate) (#$isa ?SPEC #$BinaryPredicate) (#$isa ?INV #$BinaryPredicate) (#$genlPreds ?SPEC ?GENL) (#$genlInverse ?INV ?SPEC) (?GENL 1 2) (?SPEC 1 2) (?INV 2 1)) (#$knownSentence (#$ist #$InferencePSC (?GENL 1 2)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "The knownSentence HL module should not lie about
  1246.    the expected cost of this module being more than 2.
  1247.    Nor should it have to recursively rely on the
  1248.    :REMOVAL-IST-POS-GAF module to compute the cost.")
  1249. ;;; Result(264)  <==== #<INFERENCE-UNIT-TEST 0>
  1250. ;;; CYC(265): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-UNKNOWN-SENTENCE-OF-IST-ASENT-WITH-3-CHILDREN :OWNER "goolsbey" :BUG 16413 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL #$BinaryPredicate) (#$isa ?SPEC #$BinaryPredicate) (#$isa ?INV #$BinaryPredicate) (#$genlPreds ?SPEC ?GENL) (#$genlInverse ?INV ?SPEC) (?GENL 1 2) (?SPEC 1 2) (?INV 2 1)) (#$unknownSentence (#$ist #$InferencePSC (?GENL 1 2)))))) :EXPECTED-RESULT NIL :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "The unknownSentence HL module should not lie about
  1251.    the expected cost of this module being more than 2.
  1252.    Nor should it have to recursively rely on the
  1253.    :REMOVAL-IST-POS-GAF module to compute the cost.")
  1254. ;;; Result(265)  <==== #<INFERENCE-UNIT-TEST 0>
  1255. ;;; CYC(266): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-PROPAGATE-HYPOTHETICAL-MT :OWNER "jantos" :BUG 21971 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED1 #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?PRED3 #$UnaryPredicate) (#$implies (?PRED1 ?X) (?PRED2 ?X)) (#$implies (?PRED2 ?X) (?PRED3 ?X)) (#$isa ?TERM #$Thing) (?PRED1 ?TERM)) (?PRED3 ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :FORWARD-MAX-TIME 15 :MAX-TIME 20)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Is the hypothetical mt forward propagated")
  1256. ;;; Result(266)  <==== #<INFERENCE-UNIT-TEST 0>
  1257. ;;; CYC(267): (DEFINE-INFERENCE-UNIT-TEST :SUBCOLLECTION-OF-WITH-RELATION-TO-FN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?PRED #$BinaryPredicate) (#$isa ?VAL #$Individual) (#$isa ?INS ?COL) (?PRED ?INS ?VAL) (#$isa ?INS-2 ?COL) (?PRED ?INS-2 ?VAL)) (#$isa ?X (#$SubcollectionOfWithRelationToFn ?COL ?PRED ?VAL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?INS)) ((?X . ?INS-2)))) :KB :FULL :COMMENT "Make sure that it returns the expected results")
  1258. ;;; Result(267)  <==== #<INFERENCE-UNIT-TEST 0>
  1259. ;;; CYC(268): (DEFINE-INFERENCE-UNIT-TEST :SUBCOLLECTION-OF-WITH-RELATION-TO-FN-NOT-EXCLUSIVE-UNIFY :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?PRED #$BinaryPredicate) (#$isa ?VAL #$Individual) (#$isa ?INS (#$SubcollectionOfWithRelationToFn ?COL ?PRED ?VAL))) (#$isa ?X (#$SubcollectionOfWithRelationToFn ?COL ?PRED ?VAL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?INS)))) :KB :FULL :COMMENT "Verify that the #$SubcollectionOfWithRelationToFn removal module is not exclusive.")
  1260. ;;; Result(268)  <==== #<INFERENCE-UNIT-TEST 0>
  1261. ;;; CYC(269): (DEFINE-INFERENCE-UNIT-TEST :SUBCOLLECTION-OF-WITH-RELATION-TO-FN-NOT-EXCLUSIVE-CHECK :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?PRED #$BinaryPredicate) (#$isa ?VAL #$Individual) (#$isa ?INS (#$SubcollectionOfWithRelationToFn ?COL ?PRED ?VAL))) (#$isa ?INS (#$SubcollectionOfWithRelationToFn ?COL ?PRED ?VAL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Verify that the #$SubcollectionOfWithRelationToFn removal module is not exclusive.")
  1262. ;;; Result(269)  <==== #<INFERENCE-UNIT-TEST 0>
  1263. ;;; CYC(270): (DEFINE-INFERENCE-UNIT-TEST :RECURSIVE-QUERY-PROBLEM-STORE-SHARING :OWNER "kknight" :BUG 17575 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?A #$Individual) (#$isa ?B #$Individual) (#$isa ?C #$Individual) (?PRED ?A) (?PRED ?B) (?PRED ?C)) (#$extentCardinality (#$TheSetOf ?X (?PRED ?X)) ?CARD)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 200 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?CARD . 0)))) :KB :TINY :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$extentCardinality (#$TheSetOf ?X (?PRED ?X)) ?CARD)) :EXPECTED-RESULT (((?CARD . 3))) :PROPERTIES (:PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :BROWSABLE? T) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Verify that problem stores in which recursive queries have been done
  1264.    can be safely reused for inferences with different query properties.")
  1265. ;;; Result(270)  <==== #<INFERENCE-UNIT-TEST 0>
  1266. ;;; CYC(271): (DEFINE-INFERENCE-UNIT-TEST :COMMUTATIVE-FUNCTION :OWNER "jantos" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?FUNC #$BinaryFunction) (#$isa ?FUNC #$CommutativeRelation) (#$isa ?TERM1 #$Thing) (#$isa ?TERM2 #$Thing) (?PRED (?FUNC ?TERM2 ?TERM1))) (#$and (#$equalSymbols ?X ?TERM2) (#$equalSymbols ?Y ?TERM1) (?PRED (?FUNC ?X ?Y)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?TERM2) (?Y . ?TERM1)))) :KB :FULL :COMMENT "Verify that inference can answer queries with commutative functions.")
  1267. ;;; Result(271)  <==== #<INFERENCE-UNIT-TEST 0>
  1268. ;;; CYC(272): (DEFINE-INFERENCE-UNIT-TEST :COMMUTATIVE-FUNCTION-IN-COMMUTATIVE-PREDICATE :OWNER "jantos" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$CommutativePredicate)) (#$isa ?PRED #$TernaryPredicate) (#$isa ?FUNC #$BinaryFunction) (#$isa ?FUNC #$CommutativeRelation) (#$isa ?TERM1 #$Thing) (#$isa ?TERM2 #$Thing) (?PRED (?FUNC ?TERM2 ?TERM1) ?TERM1 ?TERM1)) (#$and (#$equalSymbols ?X ?TERM2) (#$equalSymbols ?Y ?TERM1) (?PRED (?FUNC ?X ?Y) ?Y ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?TERM2) (?Y . ?TERM1)))) :KB :FULL :COMMENT "Verify that inference can answer queries with commutative functions inside commutative predicates.")
  1269. ;;; Result(272)  <==== #<INFERENCE-UNIT-TEST 0>
  1270. ;;; CYC(273): (DEFINE-INFERENCE-UNIT-TEST :THE-LIST-GIVES-LIST-EXTENSIONAL :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$quotedIsa (#$TheList #$isa #$Thing) #$List-Extensional))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Verify #$TheList NAUT is an quoted instance of #$List-Extensional.")
  1271. ;;; Result(273)  <==== #<INFERENCE-UNIT-TEST 0>
  1272. ;;; CYC(274): (DEFINE-INFERENCE-UNIT-TEST :THE-SET-GIVES-SET-EXTENSIONAL :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$quotedIsa (#$TheSet #$isa #$Thing) #$Set-Extensional))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Verify #$TheSet NAUT is an quoted instance of #$Set-Extensional.")
  1273. ;;; Result(274)  <==== #<INFERENCE-UNIT-TEST 0>
  1274. ;;; CYC(275): (DEFINE-INFERENCE-UNIT-TEST :TRIVIAL-INFINITE-RECURSION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentAsserted ?PRED)) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Assuming a negation-by-failure implementation of completeExtentAsserted,
  1275. this test should cause the trivial strategist to infinitely recurse.
  1276. This tests that the trivial strategist catches this instead of crashing.")
  1277. ;;; Result(275)  <==== #<INFERENCE-UNIT-TEST 0>
  1278. ;;; CYC(276): (DEFINE-INFERENCE-UNIT-TEST :CONJUNCTIVE-FOLLOWUP-ADDITIONAL-JOIN-ORDERED :OWNER "goolsbey" :BUG 18352 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 100) (#$integerBetween 100 ?X 200)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 100)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 100) (#$integerBetween 100 ?X 200) (#$integerBetween 90 ?X 110))) :PROPERTIES (:PRODUCTIVITY-LIMIT 200) :EXPECTED-RESULT (((?X . 100)))))) :COMMENT "Since the second query is a conjunctive followup in the same store,
  1279.    the Worker should provide the option of simply focusing a :join-ordered
  1280.    on the root problem of the previous inference.  This is a natural idiom for
  1281.    asking a sequence of increasingly constrained queries that filter the
  1282.    results from less constrained queries.")
  1283. ;;; Result(276)  <==== #<INFERENCE-UNIT-TEST 0>
  1284. ;;; CYC(277): (DEFINE-INFERENCE-UNIT-TEST :CONJUNCTIVE-FOLLOWUP-ADDITIONAL-JOIN-ORDERED-WITHOUT-INFERENCE :OWNER "goolsbey" :BUG 21796 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 100) (#$integerBetween 100 ?X 200)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 100)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$performSubL (#$SubLQuoteFn (DESTROY-INFERENCE (PREVIOUS-QUERY-INFERENCE))))) :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT (NIL)) (:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 100) (#$integerBetween 100 ?X 200) (#$integerBetween 90 ?X 110))) :PROPERTIES (:PRODUCTIVITY-LIMIT 200) :EXPECTED-RESULT (((?X . 100)))))) :COMMENT "Similar to :conjunctive-followup-additional-join-ordered
  1285.    but make sure it still works after the first inference
  1286.    has been deleted from the store.")
  1287. ;;; Result(277)  <==== #<INFERENCE-UNIT-TEST 0>
  1288. ;;; CYC(278): (DEFINE-INFERENCE-UNIT-TEST :AND-ITERATIVE-REUSE :OWNER "goolsbey" :BUG 21797 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$integerBetween 0 ?N 2)) (#$and (#$integerBetween 0 ?N 2) (#$evaluate ?DOUBLE (#$PlusFn ?N ?N))) (#$and (#$integerBetween 0 ?N 2) (#$evaluate ?DOUBLE (#$PlusFn ?N ?N)) (#$evaluate ?SQUARE (#$TimesFn ?N ?N)))))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-UNION :ALLOWED-MODULES (:NOT :SPLIT))) :EXPECTED-RESULT (QUOTE (((?N . 0)) ((?N . 1)) ((?N . 2)) ((?N . 0) (?DOUBLE . 0)) ((?N . 1) (?DOUBLE . 2)) ((?N . 2) (?DOUBLE . 4)) ((?N . 0) (?DOUBLE . 0) (?SQUARE . 0)) ((?N . 1) (?DOUBLE . 2) (?SQUARE . 1)) ((?N . 2) (?DOUBLE . 4) (?SQUARE . 4)))) :COMMENT "The second disjunct should reuse the work from the first  disjunct.
  1289.    The third  disjunct should reuse the work from the second disjunct.")
  1290. ;;; Result(278)  <==== #<INFERENCE-UNIT-TEST 0>
  1291. ;;; CYC(279): (DEFINE-INFERENCE-UNIT-TEST :OR-SHARED-CONJUNCT-REUSE :OWNER "goolsbey" :BUG 21825 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$integerBetween -2 ?DOUBLE 4) (#$integerBetween -4 ?DOUBLE 2) (#$evaluate ?DOUBLE (#$PlusFn ?DOUBLE ?DOUBLE))) (#$and (#$integerBetween -2 ?SQUARE 4) (#$integerBetween -4 ?SQUARE 2) (#$evaluate ?SQUARE (#$TimesFn ?SQUARE ?SQUARE)))))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-UNION :ALLOWED-MODULES (:NOT :SPLIT))) :EXPECTED-RESULT (QUOTE (((?DOUBLE . 0)) ((?SQUARE . 0)) ((?SQUARE . 1)))) :COMMENT "Both disjuncts should focus on
  1292.     (#$and
  1293.       (#$integerBetween -2 ?N 4)
  1294.       (#$integerBetween -4 ?N 2))
  1295.    since that will maximize reuse among the disjuncts.")
  1296. ;;; Result(279)  <==== #<INFERENCE-UNIT-TEST 0>
  1297. ;;; CYC(280): (DEFINE-INFERENCE-UNIT-TEST :OR-SHARED-CONJUNCT-NO-REUSE-IF-SPLIT :OWNER "goolsbey" :BUG 22268 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?NUM 9) (#$or (#$evaluate ?ANS (#$PlusFn ?NUM ?NUM)) (#$evaluate ?ANS (#$TimesFn ?NUM ?NUM))) (#$greaterThan 5 ?ANS)))) :PROPERTIES (QUOTE (:DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-UNION)) :EXPECTED-RESULT (QUOTE (((?NUM . 0) (?ANS . 0)) ((?NUM . 1) (?ANS . 1)) ((?NUM . 1) (?ANS . 2)) ((?NUM . 2) (?ANS . 4)))) :COMMENT "Although 0 <= NUM <= 9 and 5 > ANS are shared across both disjuncts,
  1298.    inference should not focus on their conjunction since it would be a split.")
  1299. ;;; Result(280)  <==== #<INFERENCE-UNIT-TEST 0>
  1300. ;;; CYC(281): (DEFINE-INFERENCE-UNIT-TEST :INTERVAL-SIZE-NOT-FULLY-BOUND :OWNER "kknight" :SENTENCE (QUOTE (#$intervalSize (#$YearsDuration 1 19) ?SIZE)) :EXPECTED-RESULT (QUOTE (((?SIZE #$YearsDuration 18)))) :KB :FULL :COMMENT "Make sure that intervalSize has inference support.")
  1301. ;;; Result(281)  <==== #<INFERENCE-UNIT-TEST 0>
  1302. ;;; CYC(282): (DEFINE-INFERENCE-UNIT-TEST :INTERVAL-SIZE-FULLY-BOUND :OWNER "kknight" :SENTENCE (QUOTE (#$intervalSize (#$YearsDuration 1 19) (#$YearsDuration 18))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Make sure that intervalSize has inference support.")
  1303. ;;; Result(282)  <==== #<INFERENCE-UNIT-TEST 0>
  1304. ;;; CYC(283): (DEFINE-INFERENCE-UNIT-TEST :NAT-LOOKUP-PREFERRED-WITH-DONT-CARE-VARIABLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$BinaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$resultIsa ?FUNC #$BinaryPredicate) (#$isa ?PRED #$UnaryPredicate) (#$isa ?OBJ #$Individual)) (#$and (#$evaluate ?NAT (#$EvaluateSubLFn (#$SubLQuoteFn (QUERY-ABORT)))) (#$termOfUnit ?NAT (?FUNC "a" ??X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "Make sure that the don't care variable ??X properly makes
  1305.    the #$termOfUnit preferred over the #$evaluate literal.")
  1306. ;;; Result(283)  <==== #<INFERENCE-UNIT-TEST 0>
  1307. ;;; CYC(284): (DEFINE-INFERENCE-UNIT-TEST :REUSED-SPLIT-OUGHTNT-BE-DISALLOWED :OWNER "pace" :BUG 20959 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$genls ?SPEC ?COL) (#$isa ?OP #$BinaryPredicate) (#$isa ?PSE #$BinaryPredicate) (#$isa ?CS #$TernaryPredicate) (#$isa ?TERM-1 ?COL) (?OP ?TERM-1 "word") (?PSE "the Latin word acidus" ?TERM-1) (?CS "the Latin word" "the Latin " "word")) (#$ist #$EverythingPSC (#$and (#$isa ?X ?COL) (?PSE "the Latin word acidus" ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . ?TERM-1)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$and (#$isa ?X ?COL) (?OP ?X "word") (?PSE "the Latin word acidus" ?X) (?CS ?Y "the Latin " "word"))) :EXPECTED-RESULT (((?X . ?TERM-1) (?Y . "the Latin word")))))) :COMMENT "Test that split tactics leading to good problems aren't disallowed")
  1308. ;;; Result(284)  <==== #<INFERENCE-UNIT-TEST 0>
  1309. ;;; CYC(285): (DEFINE-INFERENCE-UNIT-TEST :REUSED-SPLIT-OUGHTNT-BE-DISALLOWED-2 :OWNER "pace" :BUG 20959 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED "a") (?PRED "chaff1") (?PRED "chaff2") (?PRED "chaff3")) (#$ist #$EverythingPSC (#$thereExists ?X (#$and (#$integerBetween 1 ?Y 2) (#$equalSymbols ?Y ?Y) (?PRED ?X) (#$different ?X ?Y 3))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?Y . 1)) ((?Y . 2)))) :COMMENT "Test that split tactics leading to good problems aren't disallowed")
  1310. ;;; Result(285)  <==== #<INFERENCE-UNIT-TEST 0>
  1311. ;;; CYC(286): (DEFINE-INFERENCE-UNIT-TEST :SPEC-CARDINALITY-FOR-NEW-COLLECTION :OWNER "pace" :BUG 20968 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GENL #$Collection) (#$isa ?SPEC #$Collection) (#$genls ?SPEC ?GENL)) (#$evaluate 1 (#$EvaluateSubLFn (#$SubLQuoteFn (SPEC-CARDINALITY ?GENL))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that spec-cardinality is properly set up for a new collection with one spec.")
  1312. ;;; Result(286)  <==== #<INFERENCE-UNIT-TEST 0>
  1313. ;;; CYC(287): (DEFINE-INFERENCE-UNIT-TEST :GENL-CARDINALITY-FOR-NEW-COLLECTION :OWNER "goolsbey" :BUG 13977 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GENL #$Collection) (#$isa ?SPEC #$Collection) (#$genls ?SPEC ?GENL)) (#$thereExists ?COUNT-GENL (#$thereExists ?COUNT-SPEC (#$and (#$evaluate ?COUNT-GENL (#$EvaluateSubLFn (#$SubLQuoteFn (GENL-CARDINALITY ?GENL)))) (#$evaluate ?COUNT-SPEC (#$EvaluateSubLFn (#$SubLQuoteFn (GENL-CARDINALITY ?SPEC)))) (#$greaterThan ?COUNT-SPEC ?COUNT-GENL) (#$greaterThan ?COUNT-GENL 0))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that genl-cardinality is properly set up for new collections.")
  1314. ;;; Result(287)  <==== #<INFERENCE-UNIT-TEST 0>
  1315. ;;; CYC(288): (DEFINE-INFERENCE-UNIT-TEST :GOOD-PROBLEMS-ARE-NOT-ALWAYS-PREFERRED :OWNER "goolsbey" :BUG 20959 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 0) (#$isa ?X #$NonNegativeInteger)))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 0)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween -10 ?X 1) (#$isa ?X #$NonNegativeInteger))) :PROPERTIES (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T) :EXPECTED-RESULT (((?X . 0)) ((?X . 1)))))) :COMMENT "Test that the unexamined good problem (#$isa ?X NonNegativeInteger)
  1316.    that's already in the store from the first query is not
  1317.    necessarily considered preffered in the followup simply because
  1318.    it is good.")
  1319. ;;; Result(288)  <==== #<INFERENCE-UNIT-TEST 0>
  1320. ;;; CYC(289): (DEFINE-INFERENCE-UNIT-TEST :THROWN-AWAY-DUE-TO-PRODUCTIVITY-LIMIT-LOOKAHEAD :OWNER "pace" :SENTENCE (QUOTE (#$ist #$EverythingPSC (#$implies (#$and (#$isa ?COL #$Collection) (#$ist #$UniversalVocabularyMt (#$isa ?IND ?COL))) (#$thereExists ?X (#$thereExists ?Y (#$thereExists ?MT (#$and (#$ist-Asserted #$UniversalVocabularyMt (#$isa ?X ?COL)) (#$ist-Asserted ?MT (#$isa ?X ?Y))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TIME 3 :PRODUCTIVITY-LIMIT 200 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a join-ordered tactic leading to a problem that's thrown away
  1321. due to exceeding the productivity limit is itself thrown away.")
  1322. ;;; Result(289)  <==== #<INFERENCE-UNIT-TEST 0>
  1323. ;;; CYC(290): (DEFINE-INFERENCE-UNIT-TEST :SET-ASIDE-DUE-TO-PRODUCTIVITY-LIMIT-LOOKAHEAD :OWNER "pace" :BUG 20986 :SENTENCE (QUOTE (#$ist #$EverythingPSC (#$implies (#$and (#$isa ?COL #$Collection) (#$ist #$UniversalVocabularyMt (#$isa ?IND ?COL))) (#$thereExists ?X (#$thereExists ?Y (#$thereExists ?MT (#$and (#$ist-Asserted #$UniversalVocabularyMt (#$isa ?X ?COL)) (#$ist-Asserted ?MT (#$isa ?X ?Y))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TIME 3 :PRODUCTIVITY-LIMIT 200 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0 :ALLOW-HL-PREDICATE-TRANSFORMATION? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a join-ordered tactic leading to a problem that's set aside
  1324. due to exceeding the productivity limit is itself set aside.")
  1325. ;;; Result(290)  <==== #<INFERENCE-UNIT-TEST 0>
  1326. ;;; CYC(291): (DEFINE-INFERENCE-UNIT-TEST :FOCUS-ON-THE-MAGIC-WAND-FORWARD :OWNER "pace" :BUG 9647 :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$denotation ?VAR0 #$CountNoun ?VAR1 #$NetWorkQuantity))) :PROPERTIES (QUOTE (:BROWSABLE? T :DIRECTION :FORWARD)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$InferencePSC (#$and (#$denotation ?VAR0 #$CountNoun ?VAR1 #$NetWorkQuantity) (#$singular ?VAR0 ?VAR2))) :PROPERTIES (:MAX-TIME 3) :EXPECTED-RESULT NIL))) :COMMENT "Test that the Tactician used for forward inference focuses on the
  1327. dispreferred magic wand tactic instead of the very productive alternative.")
  1328. ;;; Result(291)  <==== #<INFERENCE-UNIT-TEST 0>
  1329. ;;; CYC(292): (DEFINE-INFERENCE-UNIT-TEST :FOCUS-ON-THE-MAGIC-WAND-BACKWARD :OWNER "pace" :BUG 9647 :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$denotation ?VAR0 #$CountNoun ?VAR1 #$NetWorkQuantity))) :PROPERTIES (QUOTE (:BROWSABLE? T :DIRECTION :BACKWARD)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$InferencePSC (#$and (#$denotation ?VAR0 #$CountNoun ?VAR1 #$NetWorkQuantity) (#$singular ?VAR0 ?VAR2))) :PROPERTIES (:MAX-TIME 3) :EXPECTED-RESULT NIL))) :COMMENT "Test that the Tactician used for backward inference focuses on
  1330. the dispreferred magic wand tactic instead of the very productive alternative.")
  1331. ;;; Result(292)  <==== #<INFERENCE-UNIT-TEST 0>
  1332. ;;; CYC(293): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-PRUNE-NEUTRAL-FORWARD :OWNER "pace" :BUG 9647 :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$behaviorCapable ?VAR0 #$SprintingForward #$perpetrator) (#$and (#$isa ?VAR1 #$TernaryPredicate) (#$performSubL (#$ExpandSubLFn (?VAR1) (PROGN (IGNORE ?VAR1) (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:DIRECTION :FORWARD)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the Tactician used for forward inference prunes the other half of
  1333. the split after finding the first half to be neutral.")
  1334. ;;; Result(293)  <==== #<INFERENCE-UNIT-TEST 0>
  1335. ;;; CYC(294): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-PRUNE-NEUTRAL-BACKWARD :OWNER "pace" :BUG 9647 :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$behaviorCapable ?VAR0 #$SprintingForward #$perpetrator) (#$and (#$isa ?VAR1 #$TernaryPredicate) (#$performSubL (#$ExpandSubLFn (?VAR1) (PROGN (IGNORE ?VAR1) (QUERY-ABORT)))))))) :PROPERTIES (QUOTE (:DIRECTION :BACKWARD)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the Tactician used for backward inference prunes the other half of
  1336.    the split after finding the first half to be neutral.")
  1337. ;;; Result(294)  <==== #<INFERENCE-UNIT-TEST 0>
  1338. ;;; CYC(295): (DEFINE-PRIVATE FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE (CONJUNCTION-PROBLEM PREDICATE) "Returns the (assumed unique) join-ordered tactic on CONJUNCTION-PROBLEM whose lookahead
  1339.    problem is a single-literal problem with predicate PREDICATE." (DO-PROBLEM-TACTICS (JO-TACTIC CONJUNCTION-PROBLEM :TYPE :JOIN-ORDERED) (CLET ((CONJUNCT-PROBLEM (JOIN-ORDERED-TACTIC-LOOKAHEAD-PROBLEM JO-TACTIC))) (PWHEN (SINGLE-LITERAL-PROBLEM-P CONJUNCT-PROBLEM) (PWHEN (EQ PREDICATE (SINGLE-LITERAL-PROBLEM-PREDICATE CONJUNCT-PROBLEM)) (RET JO-TACTIC))))) (RET NIL))
  1340. ;;; Result(295)  <==== {CYC:FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE -SubLInterpretedFunction-}
  1341. ;;; CYC(296): (DEFINE-INFERENCE-UNIT-TEST :TACTICIAN-DEAD-END-LOOKAHEAD :OWNER "pace" :WORKING? NIL :KB :FULL :BUG 21292 :SENTENCE (QUOTE (#$ist #$EverythingPSC (#$and (#$simpleQueryForFormula ?QUERY ?FORMULA) (#$means ?FORMULA (?OPERATOR . ??ARGS)) (#$backchainRequired ?OPERATOR)))) :PROPERTIES (QUOTE (:MAX-TIME 1 :BROWSABLE? T)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON :MAX-TIME :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((ROOT-PROBLEM (PREVIOUS-QUERY-ROOT-PROBLEM)) (BACKCHAIN-REQUIRED-TACTIC (FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE ROOT-PROBLEM #$backchainRequired)) (BACKCHAIN-REQUIRED-PROBLEM (JOIN-ORDERED-TACTIC-LOOKAHEAD-PROBLEM BACKCHAIN-REQUIRED-TACTIC)) (SQFF-TACTIC (FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE ROOT-PROBLEM #$simpleQueryForFormula)) (SQFF-PROBLEM (JOIN-ORDERED-TACTIC-LOOKAHEAD-PROBLEM SQFF-TACTIC))) (CAND (JOIN-ORDERED-TACTIC-P BACKCHAIN-REQUIRED-TACTIC) (EQ #$backchainRequired (SINGLE-LITERAL-PROBLEM-PREDICATE BACKCHAIN-REQUIRED-PROBLEM)) (JOIN-ORDERED-TACTIC-P SQFF-TACTIC) (EQ #$simpleQueryForFormula (SINGLE-LITERAL-PROBLEM-PREDICATE SQFF-PROBLEM)) (TACTIC-EXECUTED? SQFF-TACTIC) (CNOT (TACTIC-EXECUTED? BACKCHAIN-REQUIRED-TACTIC))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that the Tactician can look ahead to determine that solving the
  1342.    #$backchainRequired literal first would be a dead-end, so will instead
  1343.    focus initially on #$simpleQueryForFormula.")
  1344. ;;; Result(296)  <==== #<INFERENCE-UNIT-TEST 0>
  1345. ;;; CYC(297): (DEFINE-INFERENCE-UNIT-TEST :TACTICIAN-DEAD-END-LOOKAHEAD-HACK :OWNER "pace" :KB :FULL :BUG 21292 :SENTENCE (QUOTE (#$ist #$EverythingPSC (#$and (#$simpleQueryForFormula ?QUERY ?FORMULA) (#$means ?FORMULA (?OPERATOR . ??ARGS)) (#$trueSubL (#$ExpandSubLFn (?OPERATOR) (BACKCHAIN-REQUIRED? ?OPERATOR)))))) :PROPERTIES (QUOTE (:MAX-TIME 1 :BROWSABLE? T)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON :MAX-TIME :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((ROOT-PROBLEM (PREVIOUS-QUERY-ROOT-PROBLEM)) (BACKCHAIN-REQUIRED-TACTIC (FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE ROOT-PROBLEM #$trueSubL)) (BACKCHAIN-REQUIRED-PROBLEM (JOIN-ORDERED-TACTIC-LOOKAHEAD-PROBLEM BACKCHAIN-REQUIRED-TACTIC)) (SQFF-TACTIC (FIND-JOIN-ORDERED-TACTIC-LEADING-TO-SINGLE-LITERAL-PROBLEM-WITH-PREDICATE ROOT-PROBLEM #$simpleQueryForFormula)) (SQFF-PROBLEM (JOIN-ORDERED-TACTIC-LOOKAHEAD-PROBLEM SQFF-TACTIC))) (CAND (JOIN-ORDERED-TACTIC-P BACKCHAIN-REQUIRED-TACTIC) (EQ #$trueSubL (SINGLE-LITERAL-PROBLEM-PREDICATE BACKCHAIN-REQUIRED-PROBLEM)) (JOIN-ORDERED-TACTIC-P SQFF-TACTIC) (EQ #$simpleQueryForFormula (SINGLE-LITERAL-PROBLEM-PREDICATE SQFF-PROBLEM)) (TACTIC-EXECUTED? SQFF-TACTIC) (CNOT (TACTIC-EXECUTED? BACKCHAIN-REQUIRED-TACTIC))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Like :tactician-dead-end-lookahead but with a #$trueSubL hack to force the Tactician
  1346.    into choosing the correct literal")
  1347. ;;; Result(297)  <==== #<INFERENCE-UNIT-TEST 0>
  1348. ;;; CYC(298): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-JOIN-NO-GOODNESS-PROPAGATION :OWNER "goolsbey" :BUG 21255 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?X 4)) (#$performSubL (#$SubLQuoteFn (QUERY-ABORT))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that a join in which both sides are finished but no bindings
  1349.    intersect is deemed no-good.")
  1350. ;;; Result(298)  <==== #<INFERENCE-UNIT-TEST 0>
  1351. ;;; CYC(299): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-COMPLETE-JOIN-ORDERED-NO-GOODNESS-PROPAGATION :OWNER "goolsbey" :BUG 9609 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$different ?X 1 2)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$and (#$integerBetween 1 ?X 2) (#$different ?X 1 2)) (#$performSubL (#$SubLQuoteFn (QUERY-ABORT))))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Verify that the join-ordered on ?Y can be deemed no-good since the focal
  1352.    side is complete, finished and all corresponding restricted non-focals
  1353.    are finished and no-good.")
  1354. ;;; Result(299)  <==== #<INFERENCE-UNIT-TEST 0>
  1355. ;;; CYC(300): (PWHEN-FEATURE :CYC-QUANT (DEFINE-INFERENCE-UNIT-TEST :PRUNE-FINISHED-NON-GOOD-PROBLEMS :OWNER "goolsbey" :BUG 9651 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?TEN (#$thereExists ?ONE (#$and (#$integerBetween 0 ?N 99) (#$evaluate ?TEN (#$RoundDownFn (#$QuotientFn (#$ModuloFn ?N 100) 10))) (#$evaluate ?ONE (#$RoundDownFn (#$QuotientFn (#$ModuloFn ?N 10) 1))) (#$equalSymbols ?TEN ?ONE)))))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 120)) :EXPECTED-RESULT (QUOTE (((?N . 0)) ((?N . 11)) ((?N . 22)) ((?N . 33)) ((?N . 44)) ((?N . 55)) ((?N . 66)) ((?N . 77)) ((?N . 88)) ((?N . 99)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that finished problems get pruned (even if good)."))
  1356. ;;; Result(300)  <==== #<INFERENCE-UNIT-TEST 0>
  1357. ;;; CYC(301): (DEFINE-PRIVATE PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P NIL (CMULTIPLE-VALUE-BIND (PROBLEM STRATEGY) (PREVIOUS-QUERY-ROOT-PROBLEM-AND-STRATEGY) (RET (CAND (TACTICALLY-PENDING-PROBLEM-P PROBLEM) (STRATEGICALLY-PENDING-PROBLEM-P PROBLEM STRATEGY)))))
  1358. ;;; Result(301)  <==== {CYC:PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P -SubLInterpretedFunction-}
  1359. ;;; CYC(302): (DEFINE-PRIVATE PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P NIL (CMULTIPLE-VALUE-BIND (PROBLEM STRATEGY) (PREVIOUS-QUERY-ROOT-PROBLEM-AND-STRATEGY) (RET (CAND (TACTICALLY-FINISHED-PROBLEM-P PROBLEM) (STRATEGICALLY-FINISHED-PROBLEM-P PROBLEM STRATEGY)))))
  1360. ;;; Result(302)  <==== {CYC:PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P -SubLInterpretedFunction-}
  1361. ;;; CYC(303): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-GOOD-LITERAL :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$genls #$Thing ?X))) :PROPERTIES (QUOTE (:BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that a single good removal-only literal gets finished.")
  1362. ;;; Result(303)  <==== #<INFERENCE-UNIT-TEST 0>
  1363. ;;; CYC(304): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-GOOD-LITERAL-WITH-RESTRICTION :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$genls #$Thing ?X))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :BROWSABLE? T :CONTINUABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that a single good removal-only literal with restriction layer of indirection gets finished.")
  1364. ;;; Result(304)  <==== #<INFERENCE-UNIT-TEST 0>
  1365. ;;; CYC(305): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-NEUTRAL-LITERAL :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$quotedIsa ?X #$SubLInteger))) :PROPERTIES (QUOTE (:BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that a single neutral removal-only literal gets finished.")
  1366. ;;; Result(305)  <==== #<INFERENCE-UNIT-TEST 0>
  1367. ;;; CYC(306): (DEFINE-INFERENCE-UNIT-TEST :PENDING-JOIN :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 3) (#$integerBetween 2 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T :MAX-NUMBER 1 :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :EXPECTED-HALT-REASON :MAX-NUMBER :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "If a join problem executes all its tactics but has not yet finished all of its subproblems
  1368.    it should stay pending.")
  1369. ;;; Result(306)  <==== #<INFERENCE-UNIT-TEST 0>
  1370. ;;; CYC(307): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-JOIN :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that when both sides of a pending join become finished,
  1371.    the join problem becomes finished.")
  1372. ;;; Result(307)  <==== #<INFERENCE-UNIT-TEST 0>
  1373. ;;; CYC(308): (DEFINE-INFERENCE-UNIT-TEST :PENDING-JOIN-ORDERED :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 1 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T :MAX-NUMBER 1 :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :MAX-NUMBER :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "If a join-ordered problem executes all its tactics but has not yet finished all of its subproblems
  1374.    it should stay pending.")
  1375. ;;; Result(308)  <==== #<INFERENCE-UNIT-TEST 0>
  1376. ;;; CYC(309): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-JOIN-ORDERED :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$different ?X 1 2)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Given a pending join-ordered problem, when its focal problem becomes finished
  1377.    and all the restricted non-focals become finished, the join-ordered problem
  1378.    becomes finished.")
  1379. ;;; Result(309)  <==== #<INFERENCE-UNIT-TEST 0>
  1380. ;;; CYC(310): (DEFINE-INFERENCE-UNIT-TEST :PENDING-SPLIT :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?Y 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T :MAX-NUMBER 2)) :EXPECTED-RESULT (QUOTE (((?X . 1) (?Y . 3)) ((?X . 2) (?Y . 3)))) :EXPECTED-HALT-REASON :MAX-NUMBER :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "If a split problem executes all its tactics but has not yet finished all of its subproblems
  1381.    it should stay pending.")
  1382. ;;; Result(310)  <==== #<INFERENCE-UNIT-TEST 0>
  1383. ;;; CYC(311): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-SPLIT :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?Y 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1) (?Y . 3)) ((?X . 2) (?Y . 3)) ((?X . 1) (?Y . 4)) ((?X . 2) (?Y . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Given a pending split problem, once all of its conjunct problems are finished,
  1384.    the split problem becomes finished.")
  1385. ;;; Result(311)  <==== #<INFERENCE-UNIT-TEST 0>
  1386. ;;; CYC(312): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-GOOD-THEN-NO-GOOD-SPLIT :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf 1 (#$TheSet 1)) (#$elementOf 1 (#$TheSet 2))))) :PROPERTIES (QUOTE (:BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A pending split should become finished even if one conjunct is no-good.
  1387.    This handles the case where the good conjunct is worked on before the no-good one.")
  1388. ;;; Result(312)  <==== #<INFERENCE-UNIT-TEST 0>
  1389. ;;; CYC(313): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-NO-GOOD-SPLIT :OWNER "goolsbey" :BUG 21668 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$elementOf 1 (#$TheSet 2)) (#$elementOf ?X (#$TheSet 1 2))))) :PROPERTIES (QUOTE (:BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "A pending split should become finished even if one conjunct is no-good.
  1390.    This handles the case where the no-good conjunct is worked on before the good one.")
  1391. ;;; Result(313)  <==== #<INFERENCE-UNIT-TEST 0>
  1392. ;;; CYC(314): (DEFINE-INFERENCE-UNIT-TEST :PENDING-UNION :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$or (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T :MAX-NUMBER 3)) :EXPECTED-RESULT (QUOTE (((?X . 1)) ((?X . 2)) ((?X . 3)))) :EXPECTED-HALT-REASON :MAX-NUMBER :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-PENDING-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "If a union problem executes all its tactics but has not yet finished all of its subproblems
  1393.    it should stay pending.")
  1394. ;;; Result(314)  <==== #<INFERENCE-UNIT-TEST 0>
  1395. ;;; CYC(315): (DEFINE-INFERENCE-UNIT-TEST :FINISHED-UNION :OWNER "goolsbey" :BUG 4351 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$or (#$integerBetween 1 ?X 2) (#$integerBetween 3 ?X 4)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1)) ((?X . 2)) ((?X . 3)) ((?X . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (PREVIOUS-QUERY-ROOT-PROBLEM-TACTICALLY-AND-STRATEGICALLY-FINISHED-P)))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Given a pending union problem, once all of its disjunct problems are finished,
  1396.    the union problem becomes finished.")
  1397. ;;; Result(315)  <==== #<INFERENCE-UNIT-TEST 0>
  1398. ;;; CYC(316): (DEFINE-INFERENCE-UNIT-TEST :NON-EXPLANATORY-TRANSFORMATION-LINK :OWNER "goolsbey" :BUG 21279 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$isa ?T #$UnaryPredicate) (#$and (#$constantName ?P "p-Pred") (#$constantName ?Q "q-Pred") (#$constantName ?R "r-Pred") (#$constantName ?S "s-Pred") (#$constantName ?T "t-Pred")) (#$implies (#$and (?P ?X) (?Q ?X)) (?R ?X)) (#$pragmaticRequirement (?S ?X) (#$implies (#$and (?P ?X) (?Q ?X)) (?R ?X))) (#$implies (?T ?X) (?Q ?X)) (?P "a") (?S "a") (?T "a")) (?R ?OBJ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0 :RETURN :SUPPORTS)) :EXPECTED-RESULT-TEST (QUOTE LENGTHS=) :EXPECTED-RESULT 4 :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Make sure that all and only non-explanatory literals are left out
  1399.    of justifications in a 2 backchain query.  The non-explanatoriness
  1400.    comes from a transformation link.  There should be one justification
  1401.    with four supports.")
  1402. ;;; Result(316)  <==== #<INFERENCE-UNIT-TEST 0>
  1403. ;;; CYC(317): (DEFINE-INFERENCE-UNIT-TEST :NON-EXPLANATORY-RESIDUAL-TRANSFORMATION-LINK :OWNER "goolsbey" :BUG 21279 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$isa ?T #$UnaryPredicate) (#$isa ?U #$UnaryPredicate) (#$isa ?V #$UnaryPredicate) (#$and (#$constantName ?P "p-Pred") (#$constantName ?Q "q-Pred") (#$constantName ?R "r-Pred") (#$constantName ?S "s-Pred") (#$constantName ?U "u-Pred") (#$constantName ?V "v-Pred")) (#$implies (#$and (?P ?X) (?Q ?X)) (?R ?X)) (#$pragmaticRequirement (?S ?X) (#$implies (#$and (?P ?X) (?Q ?X)) (?R ?X))) (#$implies (?U ?X) (?Q ?X)) (#$pragmaticRequirement (?V ?X) (#$implies (?U ?X) (?Q ?X))) (?P "a") (?S "a") (?U "a") (?V "a")) (?R ?OBJ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0 :RETURN :SUPPORTS)) :EXPECTED-RESULT-TEST (QUOTE LENGTHS=) :EXPECTED-RESULT 4 :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Make sure that all and only non-explanatory literals are left out
  1404.    of justifications in a 2 backchain query.  The non-explanatoriness
  1405.    comes from both a transformation link and a residual transformation
  1406.    link.  There should be one justification with four supports.")
  1407. ;;; Result(317)  <==== #<INFERENCE-UNIT-TEST 0>
  1408. ;;; CYC(318): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-ARG-TYPE-VALIDATION :OWNER "goolsbey" :BUG 21374 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (?P 1)) (#$and (#$integerBetween ?X 1 ?X) (?Q ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :INTERMEDIATE-STEP-VALIDATION-LEVEL :ARG-TYPE)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that intermediate step validation
  1409.    does not error on residual transformation.")
  1410. ;;; Result(318)  <==== #<INFERENCE-UNIT-TEST 0>
  1411. ;;; CYC(319): (DEFINE-INFERENCE-UNIT-TEST :LOOKUP-BINARY-NART-VIA-ONE-ARGUMENT :OWNER "pace" :BUG 21987 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$BinaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$comment (?FUNC #$Thing #$Thing) "Reify me.")) (#$and (#$natFunction ?NART ?FUNC) (#$natArgument ?NART 1 #$Thing))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?NART ?FUNC #$Thing #$Thing)))) :EXPECTED-RESULT :EXHAUST-TOTAL :COMMENT "Ensure that we can look up a binary nart via only one of its arguments.")
  1412. ;;; Result(319)  <==== #<INFERENCE-UNIT-TEST 0>
  1413. ;;; CYC(320): (DEFINE-INFERENCE-UNIT-TEST :TRANSITIVE-ARG1-WALK-ISNT-VACUOUS :OWNER "goolsbey" :BUG 21995 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$TransitiveBinaryPredicate) (#$isa ?PRED #$ReflexiveBinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (#$isa ?TERM-3 #$Individual) (?PRED ?TERM-1 ?TERM-2) (?PRED ?TERM-2 ?TERM-3)) (?PRED ?TERM-1 ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES :REMOVAL-TRANSITIVE-ARG1-WALK :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-3)))) :EXPECTED-RESULT :EXHAUST-TOTAL :COMMENT "Ensure that the transitivity walk modules do not include vacuous 0 or 1 step walks.")
  1414. ;;; Result(320)  <==== #<INFERENCE-UNIT-TEST 0>
  1415. ;;; CYC(321): (DEFINE-INFERENCE-UNIT-TEST :TRANSITIVE-ARG2-WALK-ISNT-VACUOUS :OWNER "goolsbey" :BUG 21995 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$TransitiveBinaryPredicate) (#$isa ?PRED #$ReflexiveBinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (#$isa ?TERM-3 #$Individual) (?PRED ?TERM-1 ?TERM-2) (?PRED ?TERM-2 ?TERM-3)) (?PRED ?WHAT ?TERM-3)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES :REMOVAL-TRANSITIVE-ARG2-WALK :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-1)))) :EXPECTED-RESULT :EXHAUST-TOTAL :COMMENT "Ensure that the transitivity walk modules do not include vacuous 0 or 1 step walks.")
  1416. ;;; Result(321)  <==== #<INFERENCE-UNIT-TEST 0>
  1417. ;;; CYC(322): (DEFINE-INFERENCE-UNIT-TEST :TVA-UNIFY-CLOSURE-ISNT-VACUOUS-WRT-LOOKUP :OWNER "goolsbey" :BUG 22066 :KB :TINY :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?TVA-PRED #$SymmetricBinaryPredicate) (#$isa ?TRANS-PRED #$TransitiveBinaryPredicate) (#$transitiveViaArg ?TVA-PRED ?TRANS-PRED 2) (#$isa ?TERM-BOT #$Individual) (#$isa ?TERM-MID #$Individual) (#$isa ?TERM-TOP #$Individual) (#$isa ?TERM-X #$Individual) (?TRANS-PRED ?TERM-BOT ?TERM-MID) (?TRANS-PRED ?TERM-MID ?TERM-TOP) (?TVA-PRED ?TERM-X ?TERM-BOT)) (?TVA-PRED ?TERM-X ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES :REMOVAL-TVA-UNIFY-CLOSURE :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :TRANSITIVE-CLOSURE-MODE :ALL)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-MID)) ((?WHAT . ?TERM-TOP)))) :COMMENT "Ensure that TVA unify does not include a vacuous case handled by lookup.")
  1418. ;;; Result(322)  <==== #<INFERENCE-UNIT-TEST 0>
  1419. ;;; CYC(323): (DEFINE-INFERENCE-UNIT-TEST :TVA-UNIFY-CLOSURE-ISNT-VACUOUS-WRT-SYMMETRY :OWNER "goolsbey" :BUG 22065 :KB :TINY :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?TVA-PRED #$SymmetricBinaryPredicate) (#$isa ?TRANS-PRED #$TransitiveBinaryPredicate) (#$transitiveViaArg ?TVA-PRED ?TRANS-PRED 2) (#$isa ?TERM-BOT #$Individual) (#$isa ?TERM-MID #$Individual) (#$isa ?TERM-TOP #$Individual) (#$isa ?TERM-X #$Individual) (?TRANS-PRED ?TERM-BOT ?TERM-MID) (?TRANS-PRED ?TERM-MID ?TERM-TOP) (?TVA-PRED ?TERM-X ?TERM-BOT)) (?TVA-PRED ?WHAT ?TERM-X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES :REMOVAL-TVA-UNIFY-CLOSURE :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :TRANSITIVE-CLOSURE-MODE :ALL)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-MID)) ((?WHAT . ?TERM-TOP)))) :COMMENT "Ensure that TVA unify closure does not include a vacuous case handled by symmetry.")
  1420. ;;; Result(323)  <==== #<INFERENCE-UNIT-TEST 0>
  1421. ;;; CYC(324): (DEFINE-INFERENCE-UNIT-TEST :TVA-UNIFY-CLOSURE-ISNT-VACUOUS-WRT-GENLPREDS :OWNER "goolsbey" :BUG 22067 :KB :TINY :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?SPEC-PRED #$BinaryPredicate) (#$isa ?TVA-PRED #$SymmetricBinaryPredicate) (#$isa ?TRANS-PRED #$TransitiveBinaryPredicate) (#$genlPreds ?SPEC-PRED ?TVA-PRED) (#$transitiveViaArg ?TVA-PRED ?TRANS-PRED 2) (#$isa ?TERM-BOT #$Individual) (#$isa ?TERM-MID #$Individual) (#$isa ?TERM-TOP #$Individual) (#$isa ?TERM-X #$Individual) (?TRANS-PRED ?TERM-BOT ?TERM-MID) (?TRANS-PRED ?TERM-MID ?TERM-TOP) (?SPEC-PRED ?TERM-X ?TERM-BOT)) (?TVA-PRED ?TERM-X ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES :REMOVAL-TVA-UNIFY-CLOSURE :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :TRANSITIVE-CLOSURE-MODE :ALL)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-MID)) ((?WHAT . ?TERM-TOP)))) :COMMENT "Ensure that TVA unify closure does not include a vacuous case handled by genlPreds.")
  1422. ;;; Result(324)  <==== #<INFERENCE-UNIT-TEST 0>
  1423. ;;; CYC(325): (DEFINE-INFERENCE-UNIT-TEST :SUBCOLLECTION-INSTANCE-ITERATION-IS-PREFERRED :OWNER "goolsbey" :BUG 22101 :KB :FULL :SENTENCE (QUOTE (#$ist #$CurrentWorldDataCollectorMt-NonHomocentric (#$and (#$isa ?STATE (#$SubcollectionOfWithRelationToFn #$State-UnitedStates #$politiesBorderEachOther #$NorthDakota-State)) (#$capitalCityOfState ?STATE ?CAPITAL)))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 10)) :EXPECTED-RESULT (QUOTE (((?STATE . #$Minnesota-State) (?CAPITAL . #$CityOfSaintPaulMN)) ((?STATE . #$SouthDakota-State) (?CAPITAL . #$CityOfPierreSD)) ((?STATE . #$Montana-State) (?CAPITAL . #$CityOfHelenaMT)))) :COMMENT "Ensure that inference focuses on the isa literal rather than the capitalCityOfState literal.")
  1424. ;;; Result(325)  <==== #<INFERENCE-UNIT-TEST 0>
  1425. ;;; CYC(326): (DEFINE-INFERENCE-UNIT-TEST :META-SPLIT-PRUNING :OWNER "goolsbey" :BUG 17472 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 1 ?X 2) (#$greaterThan ?X 0) (#$greaterThan ?X 1)))) :PROPERTIES (QUOTE (:MAX-PROBLEM-COUNT 12 :BROWSABLE? T :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$and (#$greaterThan 1 1) (#$greaterThan 3 1))) :PROPERTIES (:MAX-PROBLEM-COUNT 12) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Problem store pruning should prune some no-good splits that only have
  1426.    a meta-split tactic on them (and therefore no split tactics).")
  1427. ;;; Result(326)  <==== #<INFERENCE-UNIT-TEST 0>
  1428. ;;; CYC(327): (DEFINE-INFERENCE-UNIT-TEST :SORT-SET-VIA-BIN-PRED-FN :OWNER "pace" :KB :FULL :SENTENCE (QUOTE (#$ist #$BaseKB (#$evaluate ?RESULT (#$SortSetViaBinPredFn (#$TheSet 3 1 6) #$greaterThan)))) :EXPECTED-RESULT (QUOTE (((?RESULT #$TheList 6 3 1)))) :COMMENT "Simple test for #$SortSetViaBinPredFn")
  1429. ;;; Result(327)  <==== #<INFERENCE-UNIT-TEST 0>
  1430. ;;; CYC(328): (DEFINE-INFERENCE-UNIT-TEST :SORT-SET-VIA-BIN-PRED-FN-KAPPA :OWNER "pace" :KB :FULL :SENTENCE (QUOTE (#$ist #$TKBSourceSpindleCollectorMt (#$evaluate ?RESULT (#$SortSetViaBinPredFn (#$TheSet #$Iraq #$UnitedStatesOfAmerica #$SaudiArabia #$Iran #$Canada #$Japan) (#$Kappa (?X ?Y) (#$thereExists ?TERR-X (#$thereExists ?TERR-Y (#$thereExists ?AREA-X (#$thereExists ?AREA-Y (#$and (#$territoryOf ?X ?TERR-X) (#$territoryOf ?Y ?TERR-Y) (#$areaOfRegion ?TERR-X ?AREA-X) (#$areaOfRegion ?TERR-Y ?AREA-Y) (#$greaterThan ?AREA-X ?AREA-Y))))))))))) :EXPECTED-RESULT (QUOTE (((?RESULT #$TheList #$Canada #$UnitedStatesOfAmerica #$SaudiArabia #$Iran #$Iraq #$Japan)))) :COMMENT "#$Kappa test for #$SortSetViaBinPredFn.  The kappa pred is 'areaOfRegionOfTerritoryOfGreaterThan'.")
  1431. ;;; Result(328)  <==== #<INFERENCE-UNIT-TEST 0>
  1432. ;;; CYC(329): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-1 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersectionFn (#$TheSet ?SPEC-1 ?SPEC-2)) (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?GENL-2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$genls works well with #$CollectionIntersectionFn")
  1433. ;;; Result(329)  <==== #<INFERENCE-UNIT-TEST 0>
  1434. ;;; CYC(330): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-2 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersectionFn (#$TheSet ?SPEC-1 ?UNRELATED-COL)) (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?GENL-2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "A case where #$genls ought not hold between two #$CollectionIntersectionFn narts")
  1435. ;;; Result(330)  <==== #<INFERENCE-UNIT-TEST 0>
  1436. ;;; CYC(331): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-3 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersectionFn (#$TheSet ?SPEC-1 ?SPEC-2)) (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?UNRELATED-COL)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "A case where #$genls ought not hold between two #$CollectionIntersectionFn narts")
  1437. ;;; Result(331)  <==== #<INFERENCE-UNIT-TEST 0>
  1438. ;;; CYC(332): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-4 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersectionFn (#$TheSet ?SPEC-1 ?SPEC-2 ?UNRELATED-COL)) (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?GENL-2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$genls works well with #$CollectionIntersectionFn")
  1439. ;;; Result(332)  <==== #<INFERENCE-UNIT-TEST 0>
  1440. ;;; CYC(333): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-5 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersectionFn (#$TheSet ?SPEC-1 ?SPEC-2)) (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?GENL-2 ?UNRELATED-COL)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "A case where #$genls ought not hold between two #$CollectionIntersectionFn narts")
  1441. ;;; Result(333)  <==== #<INFERENCE-UNIT-TEST 0>
  1442. ;;; CYC(334): (DEFINE-INFERENCE-UNIT-TEST :GENLS-COLLECTION-INTERSECTION-FN-6 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$isa ?UNRELATED-COL #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2)) (#$genls (#$CollectionIntersection2Fn ?SPEC-1 ?SPEC-2) (#$CollectionIntersection2Fn ?GENL-1 ?GENL-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$genls works well with #$CollectionIntersection2Fn")
  1443. ;;; Result(334)  <==== #<INFERENCE-UNIT-TEST 0>
  1444. ;;; CYC(335): (DEFINE-INFERENCE-UNIT-TEST :GENLS-FORT-COLLECTION-INTERSECTION-FN-POS-CHECK-1 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?SPEC-BOTH #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2) (#$genls ?SPEC-BOTH ?SPEC-1) (#$genls ?SPEC-BOTH ?SPEC-2)) (#$genls ?SPEC-BOTH (#$CollectionIntersectionFn (#$TheSet ?GENL-1 ?GENL-2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test #$genls between a fort and a #$CollectionIntersectionFn nat")
  1445. ;;; Result(335)  <==== #<INFERENCE-UNIT-TEST 0>
  1446. ;;; CYC(336): (DEFINE-INFERENCE-UNIT-TEST :GENLS-FORT-COLLECTION-INTERSECTION-FN-POS-CHECK-2 :OWNER "pace" :WORKING? NIL :BUG 22144 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SPEC-1 #$Collection) (#$isa ?SPEC-2 #$Collection) (#$isa ?SPEC-BOTH #$Collection) (#$isa ?GENL-1 #$Collection) (#$isa ?GENL-2 #$Collection) (#$genls ?SPEC-1 ?GENL-1) (#$genls ?SPEC-2 ?GENL-2) (#$genls ?SPEC-BOTH ?SPEC-1) (#$genls ?SPEC-BOTH ?SPEC-2)) (#$genls ?SPEC-BOTH (#$CollectionIntersection2Fn ?GENL-1 ?GENL-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test #$genls between a fort and a #$CollectionIntersection2Fn nat")
  1447. ;;; Result(336)  <==== #<INFERENCE-UNIT-TEST 0>
  1448. ;;; CYC(337): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ALL-INSTANCES-1 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa 212 ?COL)) (#$isa ?WHAT ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that non-fort all-instances are supported")
  1449. ;;; Result(337)  <==== #<INFERENCE-UNIT-TEST 0>
  1450. ;;; CYC(338): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ALL-INSTANCES-2 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa 212 ?COL) (#$isa ?GENL #$Collection) (#$genls ?COL ?GENL)) (#$isa ?WHAT ?GENL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that non-fort all-instances works for a genl")
  1451. ;;; Result(338)  <==== #<INFERENCE-UNIT-TEST 0>
  1452. ;;; CYC(339): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ISA-CHECK-1 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa 212 ?COL)) (#$isa 212 ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that non-fort isa? is supported")
  1453. ;;; Result(339)  <==== #<INFERENCE-UNIT-TEST 0>
  1454. ;;; CYC(340): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ISA-CHECK-2 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa 212 ?COL) (#$isa ?GENL #$Collection) (#$genls ?COL ?GENL)) (#$isa 212 ?GENL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that non-fort isa? works for a genl")
  1455. ;;; Result(340)  <==== #<INFERENCE-UNIT-TEST 0>
  1456. ;;; CYC(341): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ALL-ISA-1 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa "a string used only in the :non-fort-all-isa-1 inference unit test" ?COL)) (#$isa "a string used only in the :non-fort-all-isa-1 inference unit test" ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL)) ((?WHAT . #$Thing)))) :COMMENT "Test non-fort all-isa")
  1457. ;;; Result(341)  <==== #<INFERENCE-UNIT-TEST 0>
  1458. ;;; CYC(342): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-ALL-ISA-2 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa "a string used only in the :non-fort-all-isa-2 inference unit test" ?COL) (#$isa ?GENL #$Collection) (#$genls ?COL ?GENL)) (#$isa "a string used only in the :non-fort-all-isa-2 inference unit test" ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL)) ((?WHAT . ?GENL)) ((?WHAT . #$Thing)))) :COMMENT "Test non-fort all-isa")
  1459. ;;; Result(342)  <==== #<INFERENCE-UNIT-TEST 0>
  1460. ;;; CYC(343): (DEFINE-INFERENCE-UNIT-TEST :NON-FORT-NEAREST-ISA-1 :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa "a string used only in the :non-fort-nearest-isa-1 inference unit test" ?COL) (#$isa ?GENL #$Collection) (#$genls ?COL ?GENL)) (#$nearestIsa "a string used only in the :non-fort-nearest-isa-1 inference unit test" ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?COL)))) :COMMENT "Test non-fort nearestIsa")
  1461. ;;; Result(343)  <==== #<INFERENCE-UNIT-TEST 0>
  1462. ;;; CYC(344): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-LOOKAHEAD-PRODUCTIVITY-LIMIT :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 2 ?X 4) (#$integerBetween 0 ?X 10)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 300 :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)))) :COMMENT "Ensure that join-ordered lookahead productivity doesn't double the focal cost.")
  1463. ;;; Result(344)  <==== #<INFERENCE-UNIT-TEST 0>
  1464. ;;; CYC(345): (DEFINE-INFERENCE-UNIT-TEST :JOIN-LOOKAHEAD-PRODUCTIVITY-LIMIT :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 2 ?X 4) (#$integerBetween 0 ?X 10)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 1100 :ALLOWED-MODULES (:NOT :JOIN-ORDERED))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)))) :COMMENT "Ensure that join lookahead productivity doesn't sum the costs of conjunct problems.")
  1465. ;;; Result(345)  <==== #<INFERENCE-UNIT-TEST 0>
  1466. ;;; CYC(346): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-JOIN-ORDERED-LOOKAHEAD-PRODUCTIVITY-LIMIT :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 2 ?X 4) (#$integerBetween 0 ?X 10) (#$integerBetween 6 ?Y 8) (#$integerBetween 0 ?Y 10)))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 300 :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . 2) (?Y . 6)) ((?X . 2) (?Y . 7)) ((?X . 2) (?Y . 8)) ((?X . 3) (?Y . 6)) ((?X . 3) (?Y . 7)) ((?X . 3) (?Y . 8)) ((?X . 4) (?Y . 6)) ((?X . 4) (?Y . 7)) ((?X . 4) (?Y . 8)))) :COMMENT "Ensure that a split lookahead join-ordered lookahead productivity doesn't double the lookahead focal cost.")
  1467. ;;; Result(346)  <==== #<INFERENCE-UNIT-TEST 0>
  1468. ;;; CYC(347): (DEFINE-INFERENCE-UNIT-TEST :UNION-JOIN-ORDERED-LOOKAHEAD-PRODUCTIVITY-LIMIT :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$or (#$and (#$integerBetween 2 ?X 4) (#$integerBetween 0 ?X 10)) (#$and (#$integerBetween 6 ?X 8) (#$integerBetween 0 ?X 10))))) :PROPERTIES (QUOTE (:PRODUCTIVITY-LIMIT 300 :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 6)) ((?X . 7)) ((?X . 8)))) :COMMENT "Ensure that a union lookahead join-ordered lookahead productivity doesn't double the lookahead focal cost.")
  1469. ;;; Result(347)  <==== #<INFERENCE-UNIT-TEST 0>
  1470. ;;; CYC(348): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-LOOKAHEAD-PRODUCTIVITY-LIMIT-2 :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?PRED ?GENL-PRED) (?PRED #$Thing 1) (?GENL-PRED #$Thing 2)) (#$and (?GENL-PRED #$Thing ?X) (#$integerBetween 0 ?X 20))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 100 :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . 1)) ((?X . 2)))) :COMMENT "Ensure that join-ordered lookahead productivity doesn't sum the focal problem's tactic costs.")
  1471. ;;; Result(348)  <==== #<INFERENCE-UNIT-TEST 0>
  1472. ;;; CYC(349): (DEFINE-INFERENCE-UNIT-TEST :JOIN-LOOKAHEAD-PRODUCTIVITY-LIMIT-2 :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?PRED ?GENL-PRED) (?PRED #$Thing 1) (?GENL-PRED #$Thing 2)) (#$and (?GENL-PRED #$Thing ?X) (#$integerBetween 1 ?X 1))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 100 :ALLOWED-MODULES (:NOT :JOIN-ORDERED))) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :COMMENT "Ensure that join lookahead productivity doesn't sum the conjunct problems' tactic costs.")
  1473. ;;; Result(349)  <==== #<INFERENCE-UNIT-TEST 0>
  1474. ;;; CYC(350): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-JOIN-ORDERED-LOOKAHEAD-PRODUCTIVITY-LIMIT-2 :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?GENL-PRED #$BinaryPredicate) (#$genlPreds ?PRED ?GENL-PRED) (?PRED #$Thing 1) (?GENL-PRED #$Thing 2)) (#$and (?GENL-PRED #$Thing ?X) (#$integerBetween 0 ?X 20) (?GENL-PRED #$Thing ?Y) (#$integerBetween 0 ?Y 20))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 100 :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?X . 2) (?Y . 2)) ((?X . 1) (?Y . 2)) ((?X . 1) (?Y . 1)) ((?X . 2) (?Y . 1)))) :COMMENT "Ensure that split lookahead join-ordered lookahead productivity doesn't sum the lookahead focal problem's tactic costs.")
  1475. ;;; Result(350)  <==== #<INFERENCE-UNIT-TEST 0>
  1476. ;;; CYC(351): (DEFINE-INFERENCE-UNIT-TEST :RECURSIVE-QUERY-FUNCTION-TO-ARG-DATA-PRED :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DATA-PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (?DATA-PRED ?TERM-1 1) (?DATA-PRED ?TERM-2 2) (#$isa ?RULE-PRED #$BinaryPredicate) (#$implies (?DATA-PRED ?X ?N) (?RULE-PRED ?X ?N)) (#$backchainRequired ?RULE-PRED) (#$completeExtentEnumerableViaBackchain ?RULE-PRED)) (#$evaluate ?TOTAL (#$PlusAll (#$TheSet ?TERM-1 ?TERM-2) (#$FunctionToArg 2 ?DATA-PRED)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?TOTAL . 3)))) :COMMENT "Minimal pair for :recursive-query-function-to-arg-rule-pred")
  1477. ;;; Result(351)  <==== #<INFERENCE-UNIT-TEST 0>
  1478. ;;; CYC(352): (DEFINE-INFERENCE-UNIT-TEST :RECURSIVE-QUERY-FUNCTION-TO-ARG-RULE-PRED :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DATA-PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (?DATA-PRED ?TERM-1 1) (?DATA-PRED ?TERM-2 2) (#$isa ?RULE-PRED #$BinaryPredicate) (#$implies (?DATA-PRED ?X ?N) (?RULE-PRED ?X ?N)) (#$backchainRequired ?RULE-PRED) (#$completeExtentEnumerableViaBackchain ?RULE-PRED)) (#$evaluate ?TOTAL (#$PlusAll (#$TheSet ?TERM-1 ?TERM-2) (#$FunctionToArg 2 ?RULE-PRED)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?TOTAL . 3)))) :COMMENT "Verify that #$completeExtentEnumerableViaBackchain enables
  1479.    backchaining within a recursive query via #$FunctionToArg.
  1480.    Minimal pair for :recursive-query-function-to-arg-data-pred")
  1481. ;;; Result(352)  <==== #<INFERENCE-UNIT-TEST 0>
  1482. ;;; CYC(353): (DEFINE-INFERENCE-UNIT-TEST :RECURSIVE-QUERY-KNOWN-SENTENCE-DATA-PRED :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DATA-PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (?DATA-PRED ?TERM-1 1) (?DATA-PRED ?TERM-2 2) (#$isa ?RULE-PRED #$BinaryPredicate) (#$implies (?DATA-PRED ?X ?N) (?RULE-PRED ?X ?N)) (#$backchainRequired ?RULE-PRED) (#$completeExtentEnumerableViaBackchain ?RULE-PRED)) (#$knownSentence (?DATA-PRED ?TERM-1 1))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Minimal pair for :recursive-query-known-sentence-rule-pred")
  1483. ;;; Result(353)  <==== #<INFERENCE-UNIT-TEST 0>
  1484. ;;; CYC(354): (DEFINE-INFERENCE-UNIT-TEST :RECURSIVE-QUERY-KNOWN-SENTENCE-RULE-PRED :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DATA-PRED #$BinaryPredicate) (#$isa ?TERM-1 #$Individual) (#$isa ?TERM-2 #$Individual) (?DATA-PRED ?TERM-1 1) (?DATA-PRED ?TERM-2 2) (#$isa ?RULE-PRED #$BinaryPredicate) (#$implies (?DATA-PRED ?X ?N) (?RULE-PRED ?X ?N)) (#$backchainRequired ?RULE-PRED) (#$completeExtentEnumerableViaBackchain ?RULE-PRED)) (#$knownSentence (?RULE-PRED ?TERM-1 1))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that #$completeExtentEnumerableViaBackchain enables
  1485.    backchaining within a recursive query via #$knownSentence.
  1486.    Minimal pair for :recursive-query-known-sentence-data-pred")
  1487. ;;; Result(354)  <==== #<INFERENCE-UNIT-TEST 0>
  1488. ;;; CYC(355): (DEFINE-INFERENCE-UNIT-TEST :INTERMEDIATE-DONT-CARE-VARIABLE-PROOF-SIMPLIFICATION :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$implies (#$integerBetween 1 ?NUM 10) (?P 1 ?NUM)) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?N ??OTHER) (?Q ?N)) (#$isa ?R #$UnaryPredicate) (#$implies (?Q ?M) (?R ?M))) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 3 :RESULT-UNIQUENESS :BINDINGS :MAX-PROBLEM-COUNT 5 :METRICS (:PROBLEM-COUNT :PROOF-COUNT))) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "We don't need to make more than one proof of (Q 1) since
  1489.   we only care about result uniqueness wrt bindings and
  1490.   all the other proofs only vary on the don't care variable ??OTHER")
  1491. ;;; Result(355)  <==== #<INFERENCE-UNIT-TEST 0>
  1492. ;;; CYC(356): :EOF
  1493. ;;; ... w:\cyc\top\tests\inference-unit-test-cases.lisp loaded; SHA-1: 6f664db01aacb946469ef859d36d3b0fe091f463
  1494. ;;; loading w:\cyc\top\tests\inference-transformation-test-cases.lisp ...
  1495. ;;; CYC(1): (IN-PACKAGE "CYC")
  1496. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  1497. ;;; CYC(2): (CVS-ID "$Id: inference-transformation-test-cases.lisp 128543 2009-08-14 16:30:26Z pace $")
  1498. ;;; Result(2)  <==== CL:NIL
  1499. ;;; CYC(3): (DEFINE-PRIVATE UNASSERT-HIGHLY-RELEVANT-MT-OF-SENTENCE (SENTENCE) (WITH-ALL-MTS (CLET ((ASS (FIND-ASSERTION-CYCL SENTENCE)) (ASS-MT (ASSERTION-MT ASS)) (HIGHLY-RELEVANT-ASS (FIND-ASSERTION-CYCL (BQ-LIST #$highlyRelevantMt ASS-MT)))) (PWHEN HIGHLY-RELEVANT-ASS (CLET ((HIGHLY-RELEVANT-ASS-MT (ASSERTION-MT HIGHLY-RELEVANT-ASS))) (CYC-UNASSERT (BQ-LIST #$highlyRelevantMt ASS-MT) HIGHLY-RELEVANT-ASS-MT))))) (RET T))
  1500. ;;; Result(3)  <==== {CYC:UNASSERT-HIGHLY-RELEVANT-MT-OF-SENTENCE -SubLInterpretedFunction-}
  1501. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :PROPOSITIONAL-BACKCHAIN-REQUIRED-ASK-FOR-BINDINGS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P "a") (?Q "b")) (#$backchainRequired ?Q) (?P "a")) (?Q ?B)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?B . "b")))) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1502. with a fully-bound rule.")
  1503. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  1504. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-BOUND-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?Q #$UnaryPredicate) (#$implies (#$different ?X "b") (?Q ?X)) (#$backchainRequired ?Q)) (?Q "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1505. where you ask the bound version that you expect to get as an answer")
  1506. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  1507. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$backchainRequired ?Q) (?P "a")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that backchaining works for a backchainRequired predicate")
  1508. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  1509. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :TWO-DIFFERENT-MTS-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED1 #$UnaryPredicate) (#$isa ?COL #$Collection) (#$isa ?MT1 #$Microtheory) (#$ist ?MT1 (#$isa ?TERM1 ?COL)) (#$ist ?MT1 (#$forAll ?X (#$implies (#$isa ?X ?COL) (?PRED1 ?X)))) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?MT2 #$Microtheory) (#$ist ?MT2 (#$isa ?TERM2 ?COL)) (#$ist ?MT2 (#$forAll ?X (#$implies (#$isa ?X ?COL) (?PRED2 ?X))))) (#$and (#$ist ?MT1 (?PRED1 ?TERM1)) (#$ist ?MT2 (?PRED2 ?TERM2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Backchaining with two different mts")
  1510. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  1511. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :CONJUNCTIVE-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$implies (#$and (?P ?X) (?Q ?X)) (?R ?X)) (#$backchainRequired ?R) (?P "a") (?Q "a")) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1512. which needs to backchain to a conjunction.")
  1513. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  1514. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :DISJUNCTIVE-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$implies (#$and (?P ?X) (#$not (?Q ?X))) (?R ?X)) (#$backchainRequired ?R) (?P "a") (#$not (?Q "a"))) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1515. which needs to backchain to a conjunction with a negation.
  1516. Note that this rule is equivalent to
  1517.  (#$implies (?P ?X) (#$or (?Q ?X) (?R ?X)))
  1518. which is why the test is called :disjunctive-backchain-required.
  1519. ")
  1520. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  1521. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-DOUBLE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$implies (#$different ?X 1) (?P1 ?X)) (#$implies (#$different ?X 2) (?P2 ?X))) (#$and (?P1 212) (?P2 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can split a problem into two subproblems
  1522. both of which require backchaining to solve.")
  1523. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  1524. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :JOIN-DOUBLE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$implies (#$equalSymbols ?X 212) (?P1 ?X)) (#$implies (#$equalSymbols ?X 212) (?P2 ?X))) (#$and (?P1 ?WHAT) (?P2 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that we can handle a connected conjunction
  1525. in which we need to backchain on both of the conjuncts.")
  1526. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  1527. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-DOUBLE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$implies (#$equalSymbols ?X 212) (?P1 ?X)) (#$implies (#$different ?X 1) (?P2 ?X))) (#$and (?P1 ?WHAT) (?P2 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that we can handle a connected conjunction
  1528. in which we need to establish bindings via one of the
  1529. conjuncts and substitute them into the other conjunct,
  1530. i.e. a join-ordered.")
  1531. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  1532. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-UNFOCUSED-DOUBLE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P1 ?X)) (#$implies (#$different ?X 1) (?P2 ?X))) (#$and (?P1 ?WHAT) (?P2 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that we can handle a connected conjunction
  1533. in which we need to establish bindings via one of the
  1534. conjuncts and substitute them into the other conjunct,
  1535. i.e. a join-ordered.  In this test we don't know
  1536. a priori that we have to backchain on both P1 and P2,
  1537. so we rely on the Tactician to do the right thing.")
  1538. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  1539. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-UNFOCUSED-TRIPLE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$isa ?P3 #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P1 ?X)) (#$implies (#$equalSymbols ?X 212) (?P2 ?X)) (#$implies (#$equalSymbols ?X 212) (?P3 ?X))) (#$and (?P1 ?WHAT) (?P2 ?WHAT) (?P3 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that a join-ordered triple backchain works,
  1540. without using any relatively incomplete predicates like #$different.")
  1541. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  1542. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED-RESIDUAL-TRANSFORMATION-BACKCHAIN-REQUIRED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$backchainRequired ?P) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$integerBetween 30 ?WHAT 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1543. unsolvable because it's unsolvable wrt removal.")
  1544. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  1545. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED-TRANSFORMATION-BACKCHAIN-REQUIRED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$backchainRequired ?P) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$equalSymbols ?WHAT 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1546. unsolvable because it's unsolvable wrt removal.")
  1547. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  1548. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED-RESIDUAL-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$integerBetween 30 ?WHAT 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1549. unsolvable because it's unsolvable wrt removal.")
  1550. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  1551. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$equalSymbols ?WHAT 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1552. unsolvable because it's unsolvable wrt removal.")
  1553. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  1554. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-SPLIT-BACKCHAIN-REQUIRED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$backchainRequired ?P) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$equalSymbols 42 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1555. unsolvable because it's unsolvable wrt removal.")
  1556. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  1557. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-SPLIT-BACKCHAIN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$elementOf ?X (#$TheSet 42)) (?P ?X))) (#$and (#$equalSymbols 42 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Just making sure that the tactician will backchain on this instead of deeming it
  1558. unsolvable because it's unsolvable wrt removal.")
  1559. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  1560. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :MODUS-TOLLENS-PROOF-VIA-NON-WFF-REJECTED :OWNER "goolsbey" :BUG 20795 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL #$Collection) (#$genls ?GENL #$Individual) (#$isa ?SPEC #$Collection) (#$genls ?SPEC ?GENL) (#$isa ?OTHER #$Collection) (#$genls ?OTHER ?GENL) (#$disjointWith ?SPEC ?OTHER) (#$isa ?P #$UnaryPredicate) (#$arg1Isa ?P ?SPEC) (#$isa ?Q #$UnaryPredicate) (#$arg1Isa ?Q ?SPEC) (#$completelyEnumerableCollection ?GENL) (#$completelyEnumerableCollection ?SPEC) (#$completelyEnumerableCollection ?OTHER) (#$implies (#$and (?P ?X) (#$isa ?X ?GENL)) (?Q ?X)) (#$isa ?OBJ ?OTHER)) (#$not (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT NIL :COMMENT "This test verifies that a modus tollens proof that in turn depends on
  1561.    a non-WFF proof of an antecedent literal should be rejected.
  1562.    The binding of ((?X . ?OBJ)) should lead to rejection of the proof
  1563.    even if intermediate step validation is off.")
  1564. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  1565. ;;; CYC(22): (DEFINE-INFERENCE-UNIT-TEST :PRODUCTIVITY-LIMIT-TRANSFORMATION-MOTIVATION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?X1 #$Thing) (#$isa ?X2 #$Thing) (#$isa ?Y1 #$Thing) (#$isa ?Y2 #$Thing) (#$isa ?Y #$Thing) (#$implies (?R ?X) (?Q ?X)) (?Q ?X1) (?Q ?X2) (?P ?Y1) (?P ?Y2) (?P ?Y) (?R ?Y)) (#$and (?P ?WHAT) (?Q ?WHAT))))) :PROPERTIES (QUOTE (:RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :PRODUCTIVITY-LIMIT 300)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?Y)))) :KB :TINY :COMMENT "Make sure productivity limit on connected conjuction (which is currently calculated from removal tactics only) does not effect transformation motivation propagation.")
  1566. ;;; Result(22)  <==== #<INFERENCE-UNIT-TEST 0>
  1567. ;;; CYC(23): (DEFINE-INFERENCE-UNIT-TEST :RECONSIDER-SECOND-HALF-OF-SPLIT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Collection) (#$forAll ?THING (?PRED ?THING)) (#$isa ?TERM #$Collection)) (#$and (?PRED ?TERM) (#$isa ?TERM #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "We set aside the #$isa literal wrt removal, but once we use
  1568. transformation to prove (?PRED ?TERM), we need to reconsider it.")
  1569. ;;; Result(23)  <==== #<INFERENCE-UNIT-TEST 0>
  1570. ;;; CYC(24): (DEFINE-INFERENCE-UNIT-TEST :RECONSIDER-SECOND-HALF-OF-SPLIT-WITH-FOLLOWUP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Collection) (#$forAll ?THING (?PRED ?THING)) (#$isa ?TERM #$Collection)) (#$and (?PRED ?TERM) (#$isa ?TERM #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL)))) :COMMENT "We set aside the #$isa literal wrt removal, but once we are
  1571. allowed to use transformation to prove (?PRED ?TERM), we need to reconsider it.")
  1572. ;;; Result(24)  <==== #<INFERENCE-UNIT-TEST 0>
  1573. ;;; CYC(25): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-CONSEQUENT-ISA-CONSTRAINT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$arg1Isa ?PRED #$Collection)) (#$ist #$UniversalVocabularyMt (#$arg1Genl ?PRED #$Microtheory)) (#$ist #$UniversalVocabularyMt (#$forAll ?THING (?PRED ?THING)))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?TERM #$Thing) (#$and (?PRED ?TERM) (#$isa ?TERM #$Collection)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "test that we can hypothesize a term that must meet an
  1574. already existing #$isa constraint implied by the consequent")
  1575. ;;; Result(25)  <==== #<INFERENCE-UNIT-TEST 0>
  1576. ;;; CYC(26): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-WITH-CONSEQUENT-GENLS-CONSTRAINT :OWNER "jantos" :BUG 4945 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$arg1Isa ?PRED #$Collection)) (#$ist #$UniversalVocabularyMt (#$arg1Genl ?PRED #$Microtheory)) (#$ist #$UniversalVocabularyMt (#$forAll ?THING (?PRED ?THING)))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?TERM #$Thing) (#$and (?PRED ?TERM) (#$genls ?TERM #$Microtheory)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "test that we can hypothesize a term that must meet an
  1577. already existing #$genls constraint implied by the consequent
  1578.  (bug #4945)")
  1579. ;;; Result(26)  <==== #<INFERENCE-UNIT-TEST 0>
  1580. ;;; CYC(27): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-CONTINUABLE-SPLIT-WITH-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?A-PRED #$UnaryPredicate) (#$isa ?B-PRED #$UnaryPredicate) (#$backchainRequired ?A-PRED) (#$backchainRequired ?B-PRED) (#$implies (#$and (#$equalSymbols ?X-A 1) (#$different ?X-A 2)) (?A-PRED ?X-A)) (#$implies (#$and (#$equalSymbols ?X-B 2) (#$different ?X-B 1)) (?B-PRED ?X-B))) (#$and (?A-PRED ?A) (?B-PRED ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 2)))) :COMMENT "A test similar to :2-way-continuable-split-with-join-ordered but
  1581.    transformation gets factored in as well.")
  1582. ;;; Result(27)  <==== #<INFERENCE-UNIT-TEST 0>
  1583. ;;; CYC(28): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-CONTINUABLE-SPLIT-WITH-BACKCHAIN-REQUIRED-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?A-PRED #$UnaryPredicate) (#$isa ?B-PRED #$UnaryPredicate) (#$backchainRequired ?A-PRED) (#$backchainRequired ?B-PRED) (#$implies (#$equalSymbols ?X-A 1) (?A-PRED ?X-A)) (#$implies (#$equalSymbols ?X-B 2) (?B-PRED ?X-B))) (#$and (?A-PRED ?A) (?B-PRED ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 2)))) :COMMENT "A test similar to :2-way-continuable-split-with-join-ordered but
  1584.    transformation gets factored in as well.")
  1585. ;;; Result(28)  <==== #<INFERENCE-UNIT-TEST 0>
  1586. ;;; CYC(29): (DEFINE-INFERENCE-UNIT-TEST :2-WAY-CONTINUABLE-SPLIT-WITH-BACKCHAIN-REQUIRED-AND-REUSE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?A-PRED #$UnaryPredicate) (#$isa ?B-PRED #$UnaryPredicate) (#$isa ?C-PRED #$UnaryPredicate) (#$isa ?D-PRED #$UnaryPredicate) (#$backchainRequired ?A-PRED) (#$backchainRequired ?B-PRED) (#$backchainRequired ?C-PRED) (#$backchainRequired ?D-PRED) (#$implies (#$and (?C-PRED ?X-A) (#$different ?X-A 2)) (?A-PRED ?X-A)) (#$implies (#$and (?C-PRED ?X-B) (#$different ?X-B 1)) (?B-PRED ?X-B)) (#$implies (?D-PRED ?X-C) (?C-PRED ?X-C)) (#$implies (#$integerBetween 1 ?X-D 2) (?D-PRED ?X-D))) (#$and (?A-PRED ?A) (?B-PRED ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 3)) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "This test should exercise
  1587.    balanced-strategy-chooses-to-throw-away-lookahead-problem-wrt-transformation? .")
  1588. ;;; Result(29)  <==== #<INFERENCE-UNIT-TEST 0>
  1589. ;;; CYC(30): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-STRATEGIC-NO-GOODNESS-RECONSIDERATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (?P "a")) (#$and (?Q "a") (#$isa 212 #$Integer))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :CONTINUE :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Ensure that the strategic no-goodness of (?Q a) and the top-level query
  1590.    are both reconsidered on resource extension.")
  1591. ;;; Result(30)  <==== #<INFERENCE-UNIT-TEST 0>
  1592. ;;; CYC(31): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-ISA-BACKCHAIN-ENCOURAGED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$implies (?P ?X) (#$isa ?X ?COL)) (#$collectionIsaBackchainEncouraged ?COL) (?P 212)) (#$isa 212 ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$collectionIsaBackchainEncouraged
  1593. allows the inference engine to backchain to
  1594. prove (#$isa 212 ?COL) even though
  1595. :allow-hl-predicate-transformation? is nil.")
  1596. ;;; Result(31)  <==== #<INFERENCE-UNIT-TEST 0>
  1597. ;;; CYC(32): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-GENLS-BACKCHAIN-ENCOURAGED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?GENL #$Collection) (#$isa ?SPEC #$Collection) (#$implies (?P ?X) (#$genls ?X ?GENL)) (#$collectionGenlsBackchainEncouraged ?GENL) (?P ?SPEC)) (#$genls ?SPEC ?GENL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$collectionGenlsBackchainEncouraged
  1598. allows the inference engine to backchain to
  1599. prove (#$genls ?SPEC ?GENL) even though
  1600. :allow-hl-predicate-transformation? is nil.")
  1601. ;;; Result(32)  <==== #<INFERENCE-UNIT-TEST 0>
  1602. ;;; CYC(33): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-ENCOURAGED-ISA :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$implies (?P ?X) (#$isa ?X ?COL)) (#$collectionBackchainEncouraged ?COL) (?P 212)) (#$isa 212 ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$collectionBackchainEncouraged
  1603. allows the inference engine to backchain to
  1604. prove (#$isa 212 ?COL) even though
  1605. :allow-hl-predicate-transformation? is nil.")
  1606. ;;; Result(33)  <==== #<INFERENCE-UNIT-TEST 0>
  1607. ;;; CYC(34): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-ENCOURAGED-GENLS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?GENL #$Collection) (#$isa ?SPEC #$Collection) (#$implies (?P ?X) (#$genls ?X ?GENL)) (#$collectionBackchainEncouraged ?GENL) (?P ?SPEC)) (#$genls ?SPEC ?GENL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$collectionBackchainEncouraged
  1608. allows the inference engine to backchain to
  1609. prove (#$genls ?SPEC ?GENL) even though
  1610. :allow-hl-predicate-transformation? is nil.")
  1611. ;;; Result(34)  <==== #<INFERENCE-UNIT-TEST 0>
  1612. ;;; CYC(35): (DEFINE-INFERENCE-UNIT-TEST :PROPOSITIONAL-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P "a") (?Q "b")) (#$backchainRequired ?Q) (?P "a")) (?Q "b")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1613. with a fully-bound rule.")
  1614. ;;; Result(35)  <==== #<INFERENCE-UNIT-TEST 0>
  1615. ;;; CYC(36): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-ALLOWED?-OBEYED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?Q #$UnaryPredicate) (#$implies (#$equalSymbols ?X "a") (?Q ?X))) (?Q "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :TRANSFORMATION-ALLOWED? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that it doesn't backchain when transformation is not allowed in the problem store.")
  1616. ;;; Result(36)  <==== #<INFERENCE-UNIT-TEST 0>
  1617. ;;; CYC(37): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-FORBIDDEN-HONORED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$backchainForbidden ?Q) (#$implies (?P ?X) (?Q ?X)) (?P "a") (?Q "b")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "b")))) :COMMENT "Test that backchainForbidden is honored.")
  1618. ;;; Result(37)  <==== #<INFERENCE-UNIT-TEST 0>
  1619. ;;; CYC(38): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-FORBIDDEN-UNLESS-ARG-CHOSEN-HONORED :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?GENERATOR #$UnaryPredicate) (#$isa ?TESTER #$UnaryPredicate) (#$implies (#$elementOf ?N (#$TheSet 1 2)) (?GENERATOR ?N)) (#$backchainRequired ?TESTER) (#$backchainForbiddenWhenUnboundInArg ?TESTER 1) (#$implies (#$and (#$isa ?N ?COL) (#$performSubL (#$SubLQuoteFn (ABORT-CURRENT-CONTROLLING-INFERENCE)))) (?TESTER ?N)) (#$implies (#$different ?N 1) (?TESTER ?N))) (#$and (?GENERATOR ?X) (?TESTER ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :ALLOWED-MODULES (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that #$backchainForbiddenWhenUnboundInArg is honored.")
  1620. ;;; Result(38)  <==== #<INFERENCE-UNIT-TEST 0>
  1621. ;;; CYC(39): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-FORBIDDEN-UNLESS-ARG-CHOSEN-REALLY-HONORED :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?GENERATOR #$UnaryPredicate) (#$isa ?TESTER #$UnaryPredicate) (#$implies (#$elementOf ?N (#$TheSet 1 2 3 4 5)) (?GENERATOR ?N)) (#$backchainRequired ?TESTER) (#$backchainForbiddenWhenUnboundInArg ?TESTER 1) (#$implies (#$and (#$isa ?N ?COL) (#$performSubL (#$SubLQuoteFn (ABORT-CURRENT-CONTROLLING-INFERENCE)))) (?TESTER ?N)) (#$implies (#$different ?N 1) (?TESTER ?N))) (#$and (?GENERATOR ?X) (?TESTER ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :ALLOWED-MODULES (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that #$backchainForbiddenWhenUnboundInArg is really honored.
  1622. This differs from :backchain-forbidden-unless-arg-chosen-honored in that the elementOf literal
  1623. will not be an early removal.")
  1624. ;;; Result(39)  <==== #<INFERENCE-UNIT-TEST 0>
  1625. ;;; CYC(40): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-FORBIDDEN-UNLESS-ARG-CHOSEN-PREFERENCE-MODULE :OWNER "pace" :KB :FULL :BUG 20962 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?INS ?COL)) (#$and (#$ratioOfCollectionToDifferentiatedCollection #$Integer ?VAR0 (#$CollectionSubsetFn #$TerroristAttack (#$TheSetOf ?ATTACK (#$thereExists ?NUM (#$and (#$greaterThan ?NUM 5) (#$relationInstanceExistsCount #$organismKilled ?ATTACK #$Person ?NUM))))) ?VAR1) (#$termOfUnit ?VAR0 (#$CollectionSubsetFn #$TerroristSuicideBombing (#$TheSetOf ?EVENT (#$thereExists ?PERP (#$and (#$eventOccursAt ?EVENT #$Iraq) (#$perpetrator ?EVENT ?VAR2)))))) (#$assertedSentence (#$isa ?VAR2 ?COL)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?VAR0 #$CollectionSubsetFn #$TerroristSuicideBombing (#$TheSetOf ?EVENT (#$thereExists ?PERP (#$and (#$eventOccursAt ?EVENT #$Iraq) (#$perpetrator ?EVENT ?INS))))) (?VAR1 . 0) (?VAR2 . ?INS)))) :COMMENT "Test that the :backchain-forbidden-unless-arg-chosen-delay preference
  1626. module is working properly.")
  1627. ;;; Result(40)  <==== #<INFERENCE-UNIT-TEST 0>
  1628. ;;; CYC(41): (DEFINE-INFERENCE-UNIT-TEST :GENERATE-AND-TEST-WITH-TRANSFORMATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?GENERATOR #$UnaryPredicate) (#$isa ?TESTER #$UnaryPredicate) (#$implies (#$elementOf ?N (#$TheSet 1 2)) (?GENERATOR ?N)) (#$backchainRequired ?TESTER) (#$implies (#$different ?N 1) (?TESTER ?N))) (#$and (?GENERATOR ?X) (?TESTER ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :ALLOWED-MODULES (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Distilled from :backchain-forbidden-unless-arg-chosen-honored while testing residual transformation.")
  1629. ;;; Result(41)  <==== #<INFERENCE-UNIT-TEST 0>
  1630. ;;; CYC(42): (DEFINE-INFERENCE-UNIT-TEST :GENERATE-AND-TEST-WITH-TRANSFORMATION-WITHOUT-EARLY-REMOVAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?GENERATOR #$UnaryPredicate) (#$isa ?TESTER #$UnaryPredicate) (#$implies (#$elementOf ?N (#$TheSet 1 2 3 4 5)) (?GENERATOR ?N)) (#$backchainRequired ?TESTER) (#$implies (#$different ?N 1) (?TESTER ?N))) (#$and (?GENERATOR ?X) (?TESTER ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :ALLOWED-MODULES (:NOT :REMOVAL-ISA-DEFN-POS))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "This differs from :generate-and-test-with-transformation in that the focal problem is not cheap
  1631. enough to warrant early removal.")
  1632. ;;; Result(42)  <==== #<INFERENCE-UNIT-TEST 0>
  1633. ;;; CYC(43): (DEFINE-INFERENCE-UNIT-TEST :TERM-CHOSEN-SATISFIED-VIA-EARLY-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED "a") (?PRED "b") (?PRED "c") (?PRED "d") (#$implies (#$and (#$equalSymbols ?X 1) (#$termChosen ?X)) (?PRED ?X))) (#$and (#$integerBetween 1 ?X 2) (?PRED ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that early removal satisfies the #$termChosen in this rule.")
  1634. ;;; Result(43)  <==== #<INFERENCE-UNIT-TEST 0>
  1635. ;;; CYC(44): (DEFINE-INFERENCE-UNIT-TEST :TERM-CHOSEN-SATISFIED-VIA-REMOVAL-BACKTRACKING :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$and (#$equalSymbols ?X 1) (#$termChosen ?X)) (?PRED ?X))) (#$and (#$integerBetween 1 ?X 1) (?PRED ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that removal backtracking satisfies the #$termChosen in this rule.")
  1636. ;;; Result(44)  <==== #<INFERENCE-UNIT-TEST 0>
  1637. ;;; CYC(45): (DEFINE-INFERENCE-UNIT-TEST :TERM-CHOSEN-FORCES-RESTRICTED-NON-FOCAL-NEW-ROOTS :OWNER "pace" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$and (#$equalSymbols ?X 1) (#$termChosen ?X)) (?PRED ?X))) (#$and (#$integerBetween 1 ?X 20) (?PRED ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that #$termChosen doesn't block this inference from answering,
  1638. despite the fact that early removal is not applicable.
  1639. This is exactly like :term-chosen-satisfied-via-early-removal except it uses
  1640. 20 instead of 2 for the generator.")
  1641. ;;; Result(45)  <==== #<INFERENCE-UNIT-TEST 0>
  1642. ;;; CYC(46): (DEFINE-INFERENCE-UNIT-TEST :MAX-TRANSFORMATION-DEPTH-OBEYED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (?P "a") (#$isa ?Q #$UnaryPredicate) (#$backchainRequired ?Q) (#$implies (?P "a") (?Q "b"))) (?Q "b")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? NIL :MAX-TIME 1) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that it doesn't backchain when its max-transformation-depth
  1643. is zero.")
  1644. ;;; Result(46)  <==== #<INFERENCE-UNIT-TEST 0>
  1645. ;;; CYC(47): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-ON-ISA :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$implies (#$equalSymbols ?X "a") (#$isa ?X ?COL))) (#$isa "a" ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that it backchains on #$isa when :allow-hl-predicate-transformation? is enabled.
  1646. Note that the only difference between this test and :dont-backchain-on-isa
  1647. is the value of the :allow-hl-predicate-transformation? parameter, and the expected result.")
  1648. ;;; Result(47)  <==== #<INFERENCE-UNIT-TEST 0>
  1649. ;;; CYC(48): (DEFINE-INFERENCE-UNIT-TEST :DONT-BACKCHAIN-ON-ISA :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$implies (#$equalSymbols ?X "a") (#$isa ?X ?COL))) (#$isa "a" ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that it doesn't backchain on #$isa when :allow-hl-predicate-transformation? is disabled.
  1650. Note that the only difference between this test and :backchain-on-isa
  1651. is the value of the :allow-hl-predicate-transformation? parameter, and the expected result.")
  1652. ;;; Result(48)  <==== #<INFERENCE-UNIT-TEST 0>
  1653. ;;; CYC(49): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-ON-SPEC-PRED-OF-ISA :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?PRED #$BinaryPredicate) (#$genlPreds ?PRED #$isa) (#$implies (#$equalSymbols ?X "a") (?PRED ?X ?COL))) (#$isa "a" ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that it backchains on #$isa via a spec-pred when :allow-hl-predicate-transformation? is enabled.
  1654. This is interestingly different than the analogous test for #$isa because
  1655. it's using a general-purpose transformation module instead of an isa-specific one.
  1656. Note that the only difference between this test and :dont-backchain-on-spec-pred-of-isa
  1657. is the value of the :allow-hl-predicate-transformation? parameter and the expected result.")
  1658. ;;; Result(49)  <==== #<INFERENCE-UNIT-TEST 0>
  1659. ;;; CYC(50): (DEFINE-INFERENCE-UNIT-TEST :DONT-BACKCHAIN-ON-SPEC-PRED-OF-ISA :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?PRED #$BinaryPredicate) (#$genlPreds ?PRED #$isa) (#$implies (#$equalSymbols ?X "a") (?PRED ?X ?COL))) (#$isa "a" ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that it doesn't backchain on #$elementOf when :allow-hl-predicate-transformation? is disabled.
  1660. This is interestingly different than the analogous test for #$isa because
  1661. it's using a general-purpose transformation module instead of an isa-specific one.
  1662. Note that the only difference between this test and :backchain-on-spec-pred-of-isa
  1663. is the value of the :allow-hl-predicate-transformation? parameter and the expected result.")
  1664. ;;; Result(50)  <==== #<INFERENCE-UNIT-TEST 0>
  1665. ;;; CYC(51): (DEFINE-INFERENCE-UNIT-TEST :TRANS-ISA-GENLPREDS-POS :OWNER "goolsbey" :WORKING? NIL :BUG 4309 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$implies (#$equalSymbols ?X "a") (#$isa ?X ?COL))) (#$elementOf "a" ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-HL-PREDICATE-TRANSFORMATION? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "A future extension.  It currently fails because trans-predicate-genlpreds-pos
  1666. kicks in and finds #$isa, but only looks for #$isa in the predicate rule index,
  1667. but doesn't look in the isa rule index.  The rule asserted in the antecedent is
  1668. only indexed under the isa rule index, so trans-predicate-genlpreds-pos can't
  1669. find it.  We could add a new transformation module to handle this case.")
  1670. ;;; Result(51)  <==== #<INFERENCE-UNIT-TEST 0>
  1671. ;;; CYC(52): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-USING-UNBOUND-PREDICATE-RULE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$and (#$equalSymbols ?UNBOUND-PRED ?PRED) (#$equalSymbols ?X "a")) (?UNBOUND-PRED ?X))) (?PRED "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-UNBOUND-PREDICATE-TRANSFORMATION? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that it backchains with unbound predicate rules when :allow-unbound-predicate-transformation? is enabled.
  1672. Note that the only difference between this test and :dont-backchain-using-unbound-predicate-rule
  1673. is the value of the :allow-unbound-predicate-transformation? parameter and the expected result.")
  1674. ;;; Result(52)  <==== #<INFERENCE-UNIT-TEST 0>
  1675. ;;; CYC(53): (DEFINE-INFERENCE-UNIT-TEST :DONT-BACKCHAIN-USING-UNBOUND-PREDICATE-RULE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$and (#$equalSymbols ?UNBOUND-PRED ?PRED) (#$equalSymbols ?X "a")) (?UNBOUND-PRED ?X))) (?PRED "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOW-UNBOUND-PREDICATE-TRANSFORMATION? NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that it doesn't backchain with unbound predicate rules when :allow-unbound-predicate-transformation? is disabled.
  1676. Note that the only difference between this test and :backchain-using-unbound-predicate-rule
  1677. is the value of the :allow-unbound-predicate-transformation? parameter and the expected result.")
  1678. ;;; Result(53)  <==== #<INFERENCE-UNIT-TEST 0>
  1679. ;;; CYC(54): (DEFINE-INFERENCE-UNIT-TEST :CONDITIONAL-CLOSED-EXISTENTIAL-RULE :OWNER "goolsbey" :BUG 9644 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$forAll ?OBJ (#$implies (#$equals ?OBJ 212) (#$thereExists ?X (?PRED ?OBJ ?X))))) (?PRED 212 213)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "A conditional query with an explicitly closed existential rule
  1680.    should not result in a tautology.
  1681.    Either this or :conditional-open-existential-rule must be the correct
  1682.    idiom for tests like this.")
  1683. ;;; Result(54)  <==== #<INFERENCE-UNIT-TEST 0>
  1684. ;;; CYC(55): (DEFINE-INFERENCE-UNIT-TEST :CONDITIONAL-OPEN-EXISTENTIAL-RULE :OWNER "goolsbey" :WORKING? NIL :BUG 9644 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$implies (#$equals ?OBJ 212) (#$thereExists ?X (?PRED ?OBJ ?X)))) (?PRED 212 213)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "A conditional query with an open existential rule
  1685.    should not be canonicalzed with universal quantification on ?X.
  1686.    Either this or :conditional-closed-existential-rule must be the correct
  1687.    idiom for tests like this.")
  1688. ;;; Result(55)  <==== #<INFERENCE-UNIT-TEST 0>
  1689. ;;; CYC(56): (DEFINE-INFERENCE-UNIT-TEST :FILTER-SKOLEM-RESULT :OWNER "jantos" :BUG 9644 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$forAll ?OBJ (#$implies (#$equals ?OBJ 212) (#$thereExists ?X (?PRED ?OBJ ?X))))) (?PRED 212 ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-INDETERMINATE-RESULTS? NIL :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Verify that :allow-indeterminate-results? nil will filter a binding to
  1690.    a use of a #$SkolemFunction.")
  1691. ;;; Result(56)  <==== #<INFERENCE-UNIT-TEST 0>
  1692. ;;; CYC(57): (DEFINE-INFERENCE-UNIT-TEST :BASIC-LIFTING :OWNER "kknight" :CREATOR "hagen" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?WAS #$UnaryPredicate) (#$isa ?MT-TIME #$BinaryPredicate) (#$isa ?LATER #$BinaryPredicate) (#$isa ?PRED #$UnaryPredicate) (#$implies (#$and (#$ist ?PAST-MT ?PROP) (?LATER ?PAST-MT ?PRESENT-MT)) (#$ist ?PRESENT-MT (?WAS ?PROP))) (#$isa ?OLD-MT #$Microtheory) (#$isa ?NEW-MT #$Microtheory) (?LATER ?OLD-MT ?NEW-MT) (#$ist ?OLD-MT (?PRED #$Thing))) (#$ist ?NEW-MT (?WAS (?PRED #$Thing)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can do lifting across different mts")
  1693. ;;; Result(57)  <==== #<INFERENCE-UNIT-TEST 0>
  1694. ;;; CYC(58): (DEFINE-INFERENCE-UNIT-TEST :N-FACTORIAL-PROOFS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$isa ?P3 #$UnaryPredicate) (#$isa ?P4 #$UnaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$backchainRequired ?P3) (#$backchainRequired ?P4) (#$implies (#$different ?X 1) (?P1 ?X)) (#$implies (#$different ?X 2) (?P2 ?X)) (#$implies (#$different ?X 3) (?P3 ?X)) (#$implies (#$different ?X 4) (?P4 ?X))) (#$and (?P1 212) (?P2 212) (?P3 212) (?P4 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we don't get n! proofs.  Currently this has to be done
  1695. by inspection of the problem store -- we should extend the testing
  1696. harness to be able to verify this automatically.")
  1697. ;;; Result(58)  <==== #<INFERENCE-UNIT-TEST 0>
  1698. ;;; CYC(59): (DEFINE-INFERENCE-UNIT-TEST :N-FACTORIAL-CONNECTED-CONJUNCTION-PROOFS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$UnaryPredicate) (#$isa ?P2 #$UnaryPredicate) (#$isa ?P3 #$UnaryPredicate) (#$isa ?P4 #$UnaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$backchainRequired ?P3) (#$backchainRequired ?P4) (#$implies (#$equalSymbols ?X 212) (?P1 ?X)) (#$implies (#$equalSymbols ?X 212) (?P2 ?X)) (#$implies (#$equalSymbols ?X 212) (?P3 ?X)) (#$implies (#$equalSymbols ?X 212) (?P4 ?X))) (#$and (?P1 ?WHAT) (?P2 ?WHAT) (?P3 ?WHAT) (?P4 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "Test that we don't get n! proofs from connected conjunctions.  Currently this has to be done
  1699. by inspection of the problem store -- we should extend the testing
  1700. harness to be able to verify this automatically.")
  1701. ;;; Result(59)  <==== #<INFERENCE-UNIT-TEST 0>
  1702. ;;; CYC(60): (DEFINE-INFERENCE-UNIT-TEST :SIMPLEST-BACKCHAIN-LOOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$implies (?Q ?X) (?P ?X)) (?P "a")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test to make sure the Worker can handle loops in the
  1703. problem store")
  1704. ;;; Result(60)  <==== #<INFERENCE-UNIT-TEST 0>
  1705. ;;; CYC(61): (DEFINE-INFERENCE-UNIT-TEST :TRIPLE-BACKCHAIN-LOOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$implies (?Q ?X) (?R ?X)) (#$implies (?R ?X) (?P ?X)) (?P "a")) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test to make sure the Worker can handle loops of
  1706. size 3 in the problem store")
  1707. ;;; Result(61)  <==== #<INFERENCE-UNIT-TEST 0>
  1708. ;;; CYC(62): (DEFINE-INFERENCE-UNIT-TEST :TWO-VARIABLE-BACKCHAIN-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$BinaryPredicate) (#$isa ?R #$BinaryPredicate) (#$implies (#$and (?P ?X ?Y) (?Q ?Y ?Z)) (?R ?X ?Z)) (#$backchainRequired ?R) (?P "a" "b") (?Q "b" "c")) (?R ?A ?C)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . "a") (?C . "c")))) :COMMENT "Test that backchaining works for a backchainRequired predicate
  1709. which needs to backchain to a conjunction with shared variables.
  1710. Note that the rule in this test is effectively implementing
  1711. transitivity via backchaining.")
  1712. ;;; Result(62)  <==== #<INFERENCE-UNIT-TEST 0>
  1713. ;;; CYC(63): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-RESIDUAL-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$elementOf ?X (#$TheSet 1 2)) (?P ?X))) (#$and (?P ?WHAT) (#$elementOf 1 (#$TheSet ?WHAT)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :COMMENT "The simplest case where residual transformation is needed to answer the query.")
  1714. ;;; Result(63)  <==== #<INFERENCE-UNIT-TEST 0>
  1715. ;;; CYC(64): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-TWO-STEP :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$implies (#$and (#$quotedIsa ?X #$SubLInteger) (#$equalSymbols ?X 212)) (?Q ?X)) (#$implies (#$and (?Q ?X) (#$isa ?X #$Thing)) (?R ?X))) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :COMMENT "A simple two-step transformation: a regular transformation followed by a residual transformation.")
  1716. ;;; Result(64)  <==== #<INFERENCE-UNIT-TEST 0>
  1717. ;;; CYC(65): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-TWO-STEP-EXPERIENCE :OWNER "pace" :BUG 18422 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$implies (#$and (#$quotedIsa ?X #$SubLInteger) (#$equalSymbols ?X 212)) (?Q ?X)) (#$implies (#$and (?Q ?X) (#$isa ?X #$Thing)) (?R ?X))) (?R ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (CAND (PLUSP (TRANSFORMATION-RULE-SUCCESS-COUNT (FIND-ASSERTION-CYCL (QUOTE (#$implies (#$and (#$quotedIsa ?X #$SubLInteger) (#$equalSymbols ?X 212)) (?Q ?X)))))) (PLUSP (TRANSFORMATION-RULE-SUCCESS-COUNT (FIND-ASSERTION-CYCL (QUOTE (#$implies (#$and (?Q ?X) (#$isa ?X #$Thing)) (?R ?X)))))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that experience is gathered correctly for residual transformation proofs.
  1718.    This test is exactly like @xref residual-transformation-two-step except it has a followup.")
  1719. ;;; Result(65)  <==== #<INFERENCE-UNIT-TEST 0>
  1720. ;;; CYC(66): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$forAll ?X (?P ?X)) (#$backchainRequired ?P)) (?P "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that backchaining works for a rule with no neg-lits.")
  1721. ;;; Result(66)  <==== #<INFERENCE-UNIT-TEST 0>
  1722. ;;; CYC(67): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RESIDUAL-TRANSFORMATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$forAll ?X (?P ?X ?X)) (#$backchainRequired ?P)) (#$ist #$EverythingPSC (?P ?Y "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?Y . "a")))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$and (#$elementOf "a" (#$TheSet ?Y)) (?P ?Y "a"))) :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1) :EXPECTED-RESULT (((?Y . "a")))))) :COMMENT "Test that residual transformation works for a rule with no neg-lits.")
  1723. ;;; Result(67)  <==== #<INFERENCE-UNIT-TEST 0>
  1724. ;;; CYC(68): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RESIDUAL-TRANSFORMATION-EXPERIENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$forAll ?X (?P ?X ?X)) (#$backchainRequired ?P)) (#$ist #$EverythingPSC (?P ?Y "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?Y . "a")))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$and (#$elementOf "a" (#$TheSet ?Y)) (?P ?Y "a"))) :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T) :EXPECTED-RESULT (((?Y . "a")))) (:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (PLUSP (TRANSFORMATION-RULE-SUCCESS-COUNT (FIND-ASSERTION-CYCL (QUOTE (#$forAll ?X (?P ?X ?X))))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that the experience success count gets incremented for single-literal residual transformation.
  1725.    This test is just like @xref :single-literal-residual-transformation except it has an additional followup.")
  1726. ;;; Result(68)  <==== #<INFERENCE-UNIT-TEST 0>
  1727. ;;; CYC(69): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-UNIFY-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?INS ?COL) (#$arg1Isa ?P ?COL) (#$forAll ?X (?P ?X)) (#$backchainRequired ?P)) (?P ?INS)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that backchaining works for a rule with no neg-lits
  1728. and an arg constraint in the fully-bound case.")
  1729. ;;; Result(69)  <==== #<INFERENCE-UNIT-TEST 0>
  1730. ;;; CYC(70): (DEFINE-INFERENCE-UNIT-TEST :DONT-CARE-SEQUENCE-VARIABLE-BACKCHAIN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$equalSymbols ?FUNC #$TheSet) (?PRED (?FUNC . ??ARGS)))) (?PRED (#$TheSet 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that backchaining works for a rule with a don't-care sequence variable
  1731.    when the sequence variable gets bound.")
  1732. ;;; Result(70)  <==== #<INFERENCE-UNIT-TEST 0>
  1733. ;;; CYC(71): (DEFINE-INFERENCE-UNIT-TEST :UNBOUND-SEQUENCE-VARIABLE-BACKCHAIN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$equalSymbols ?FUNC #$TheSet) (?PRED (?FUNC . ??ARGS)))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :PRODUCTIVITY-LIMIT 1000)) :EXPECTED-RESULT NIL :COMMENT "Test that backchaining doesn't crash for a rule with a don't-care sequence variable
  1734.    when the sequence variable does not get bound.")
  1735. ;;; Result(71)  <==== #<INFERENCE-UNIT-TEST 0>
  1736. ;;; CYC(72): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-BINDS-DONT-CARE-VARIABLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?PRED #$BinaryPredicate) (#$arg1Isa ?PRED ?COL) (#$arg2Isa ?PRED ?COL) (#$implies (#$isa ?A ?COL) (?PRED ?A ??B)) (#$isa ?TERM-1 ?COL) (#$isa ?TERM-2 ?COL)) (?PRED ?TERM-1 ?TERM-2)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :MAX-PROOF-DEPTH 2)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "This test ensures that the transformation using the rule does not introduce a
  1737.    non-explanatory constraint on ??B since it gets fully-bound to ?TERM-2.")
  1738. ;;; Result(72)  <==== #<INFERENCE-UNIT-TEST 0>
  1739. ;;; CYC(73): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-DIFFERENT-VARIABLE-SPACES :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$disjointWith ?COL #$RealNumber) (#$isa ?INS ?COL) (#$arg1Isa ?P ?COL) (#$arg2Isa ?P ?COL) (#$implies (#$different ?X 212) (?P ?X ??WHATEVER)) (#$backchainRequired ?P)) (?P ?WHAT ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?INS)))) :COMMENT "Test that the code to add additional pos-lits when
  1740. backchaining on single-literal rules is paying attention
  1741. to the right variable spaces.")
  1742. ;;; Result(73)  <==== #<INFERENCE-UNIT-TEST 0>
  1743. ;;; CYC(74): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-GENERATE-INSTANCES-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?INS ?COL) (#$arg1Isa ?P ?COL) (#$forAll ?X (?P ?X)) (#$backchainRequired ?P)) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?INS)))) :COMMENT "Test that backchaining works for a rule with no neg-lits
  1744. and an #$isa arg constraint in the not-fully-bound case.")
  1745. ;;; Result(74)  <==== #<INFERENCE-UNIT-TEST 0>
  1746. ;;; CYC(75): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-GENERATE-SPECS-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TYPE-COL #$Collection) (#$genls ?TYPE-COL #$Collection) (#$arg1Isa ?P ?TYPE-COL) (#$arg1Genl ?P ?COL) (#$isa ?RIGHT-SPEC ?TYPE-COL) (#$genls ?RIGHT-SPEC ?COL) (#$isa ?WRONG-INS ?TYPE-COL) (#$genls ?WRONG-INS #$Collection) (#$isa ?WRONG-SPEC #$Collection) (#$genls ?WRONG-SPEC ?COL) (#$forAll ?X (?P ?X)) (#$backchainRequired ?P)) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?RIGHT-SPEC)))) :COMMENT "Test that backchaining works for a rule with no neg-lits
  1747. and both #$isa and #$genls arg constraints in the not-fully-bound case.")
  1748. ;;; Result(75)  <==== #<INFERENCE-UNIT-TEST 0>
  1749. ;;; CYC(76): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-INVALID-CLOSED-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$arg1Isa ?P #$Individual) (#$isa ?WRONG-INS #$Thing) (#$forAll ?X (?P ?X)) (#$backchainRequired ?P)) (?P ?WRONG-INS)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ARG-TYPE :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Test that backchaining does not admit a semantically
  1750. invalid proof obtained via single-literal backchain.")
  1751. ;;; Result(76)  <==== #<INFERENCE-UNIT-TEST 0>
  1752. ;;; CYC(77): (DEFINE-INFERENCE-UNIT-TEST :HEINOUS-UNIFICATION-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?HEINOUS #$VariableArityRelation) (#$isa ?HEINOUS #$Predicate) (#$backchainRequired ?HEINOUS) (#$isa ?ANTE #$QuaternaryPredicate) (#$isa ?CONSEQ #$UnaryPredicate) (?ANTE "x" "d" "f" "g") (#$not (?CONSEQ "x")) (#$implies (#$and (?ANTE ?X ?Z ?W ?U) (#$different ?X ?Z ?W ?U) (#$equals ?SET-X (#$TheSet "a"))) (#$or (?CONSEQ ?X) (?HEINOUS ?SET-X "b" ??Y ?Z ?Z ?W ??V (#$TheSet ?U))))) (?HEINOUS (#$TheSet ?A) ?B "c" ?D1 ?D2 ?F ?F ?SET-G)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . "a") (?B . "b") (?D1 . "d") (?D2 . "d") (?F . "f") (?SET-G #$TheSet "g")))) :COMMENT "Test that we've covered all the heinously complicated cases that can
  1753. arise in backchaining from unifying lots of weird things.")
  1754. ;;; Result(77)  <==== #<INFERENCE-UNIT-TEST 0>
  1755. ;;; CYC(78): (PROGN (DEFINE-PRIVATE HEINOUS-RESIDUAL-TRANSFORMATION-BACKCHAIN-HELPER (STORE) (PWHEN (= 1 (PROBLEM-STORE-RESIDUAL-TRANSFORMATION-LINK-COUNT STORE)) (CLET ((RT-LINK (PROBLEM-STORE-FIRST-LINK-OF-TYPE STORE :RESIDUAL-TRANSFORMATION)) (RESIDUAL-PROBLEM (RESIDUAL-TRANSFORMATION-LINK-RESIDUAL-PROBLEM RT-LINK)) (RESIDUAL-CONJUNCTION-MAPPED-PROBLEM (RESIDUAL-TRANSFORMATION-LINK-SUPPORTING-MAPPED-PROBLEM RT-LINK)) (RESIDUAL-CONJUNCTION-PROBLEM (MAPPED-PROBLEM-PROBLEM RESIDUAL-CONJUNCTION-MAPPED-PROBLEM)) (VARIABLE-MAP (MAPPED-PROBLEM-VARIABLE-MAP RESIDUAL-CONJUNCTION-MAPPED-PROBLEM)) (VARIABLE-NUMBERS (TRANSFORM VARIABLE-MAP (FUNCTION VARIABLE-P) (FUNCTION VARIABLE-ID)))) (PWHEN (SETS-EQUAL? VARIABLE-NUMBERS (QUOTE ((3 . 2) (2 . 1) (1 . 0) (0 . 150))) (FUNCTION EQUAL)) (CLET ((ASENT (SINGLE-LITERAL-PROBLEM-ATOMIC-SENTENCE RESIDUAL-PROBLEM)) (EL-ASENT (HL-TO-EL ASENT))) (PWHEN (EQUAL (FORMULA-ARGS EL-ASENT) (QUOTE (?VAR0 ?VAR1 ?VAR2 "bv2"))) (CLET ((CONTEXTUALIZED-DNF (PROBLEM-SOLE-CLAUSE RESIDUAL-CONJUNCTION-PROBLEM))) (PWHEN (CAND (= 0 (LENGTH (NEG-LITS CONTEXTUALIZED-DNF))) (= 2 (LENGTH (POS-LITS CONTEXTUALIZED-DNF)))) (CDESTRUCTURING-BIND ((MT-A EL-ASENT-A) (MT-D EL-ASENT-D)) (HL-TO-EL (POS-LITS CONTEXTUALIZED-DNF)) (PWHEN (CAND (EQ MT-A MT-D) (EQUAL (FORMULA-ARGS EL-ASENT-A) (QUOTE (?VAR0 ?VAR1 "by2" "chaff" "chaff" "chaff"))) (EQUAL (FORMULA-ARGS EL-ASENT-D) (QUOTE (?VAR1 ?VAR2 ?VAR3 "bv2")))) (RET T))))))))))) (DEFINE-INFERENCE-UNIT-TEST :HEINOUS-RESIDUAL-TRANSFORMATION-BACKCHAIN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$VariableArityRelation) (#$isa ?PRED-A #$Predicate) (#$isa ?PRED-B #$QuintaryPredicate) (#$isa ?PRED-D #$QuaternaryPredicate) (?PRED-A "x" "y1" "by2" "chaff" "chaff" "chaff") (?PRED-D "y1" "z1" "w" "bv2") (#$implies (?PRED-D ?RY1 ?RZ1 ?RW ?RV) (?PRED-B ?RY1 "by2" ?RZ1 "bz2" ?RV))) (#$and (?PRED-A ?X ?Y1 ?Y2 "chaff" "chaff" "chaff") (?PRED-B ?Y1 ?Y2 ?Z1 ?Z2 "bv2"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . "x") (?Y1 . "y1") (?Y2 . "by2") (?Z1 . "z1") (?Z2 . "bz2")))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (HEINOUS-RESIDUAL-TRANSFORMATION-BACKCHAIN-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE))))) :PROPERTIES (:CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that we've covered all the heinously complicated cases that can
  1756. arise during the residual transformation link handling."))
  1757. ;;; Result(78)  <==== #<INFERENCE-UNIT-TEST 0>
  1758. ;;; CYC(79): (DEFINE-INFERENCE-UNIT-TEST :HEINOUS-RESIDUAL-TRANSFORMATION-BACKCHAIN-EXPERIENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$VariableArityRelation) (#$isa ?PRED-A #$Predicate) (#$isa ?PRED-B #$QuintaryPredicate) (#$isa ?PRED-D #$QuaternaryPredicate) (?PRED-A "x" "y1" "by2" "chaff" "chaff" "chaff") (?PRED-D "y1" "z1" "w" "bv2") (#$implies (?PRED-D ?RY1 ?RZ1 ?RW ?RV) (?PRED-B ?RY1 "by2" ?RZ1 "bz2" ?RV))) (#$and (?PRED-A ?X ?Y1 ?Y2 "chaff" "chaff" "chaff") (?PRED-B ?Y1 ?Y2 ?Z1 ?Z2 "bv2"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . "x") (?Y1 . "y1") (?Y2 . "by2") (?Z1 . "z1") (?Z2 . "bz2")))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (PLUSP (TRANSFORMATION-RULE-SUCCESS-COUNT (FIND-ASSERTION-CYCL (QUOTE (#$implies (?PRED-D ?RY1 ?RZ1 ?RW ?RV) (?PRED-B ?RY1 "by2" ?RZ1 "bz2" ?RV))))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that the experience success count gets incremented for a heinous residual transformation.
  1759.    This test is just like @xref :heinous-residual-transformation except it has a different followup.")
  1760. ;;; Result(79)  <==== #<INFERENCE-UNIT-TEST 0>
  1761. ;;; CYC(80): (DEFINE-INFERENCE-UNIT-TEST :POWERSET-BACKCHAIN-ORDER-REQUIRED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$BinaryPredicate) (?P 0 212) (?Q 0 212) (#$implies (#$equalSymbols ?Y 212) (?P 1 ?Y)) (#$implies (#$different ?Y 42) (?Q 1 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?Q 2 ?Y)) (#$implies (#$different ?Y 42) (?P 2 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?P 3 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?Q 3 ?Y))) (#$and (#$integerBetween 0 ?X 3) (?P ?X ?Y) (?Q ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 0) (?Y . 212)) ((?X . 1) (?Y . 212)) ((?X . 2) (?Y . 212)) ((?X . 3) (?Y . 212)))) :COMMENT "Test that exercises all combinations of potential backchain order to solve.")
  1762. ;;; Result(80)  <==== #<INFERENCE-UNIT-TEST 0>
  1763. ;;; CYC(81): (DEFINE-PRIVATE SUCCESSOR-FN-RABBIT-HOLE-BINDINGS-TEST (BINDING-LISTS &OPTIONAL EXPECTED-RESULT) (IGNORE EXPECTED-RESULT) (PWHEN (SINGLETON? BINDING-LISTS) (CLET ((BINDINGS (FIRST BINDING-LISTS)) (SEQ (VARIABLE-LOOKUP (QUOTE ?SEQ) BINDINGS))) (PWHEN (NULL SEQ) (CLET ((ONE (VARIABLE-LOOKUP (QUOTE ?ONE) BINDINGS))) (PWHEN (EL-ZERO-ARITY-FORMULA-P ONE) (CLET ((SUCCESSOR-FN (NAT-FUNCTOR ONE)) (TWO (VARIABLE-LOOKUP (QUOTE ?TWO) BINDINGS))) (PWHEN (CAND (EL-UNARY-FORMULA-P TWO) (EQ SUCCESSOR-FN (NAT-FUNCTOR TWO)) (EQUAL ONE (NAT-ARG1 TWO))) (CLET ((THREE (VARIABLE-LOOKUP (QUOTE ?THREE) BINDINGS))) (PWHEN (CAND (EL-BINARY-FORMULA-P THREE) (EQ SUCCESSOR-FN (NAT-FUNCTOR THREE)) (EQUAL TWO (NAT-ARG1 THREE)) (EQUAL ONE (NAT-ARG2 THREE))) (RET T)))))))))))
  1764. ;;; Result(81)  <==== {CYC:SUCCESSOR-FN-RABBIT-HOLE-BINDINGS-TEST -SubLInterpretedFunction-}
  1765. ;;; CYC(82): (DEFINE-INFERENCE-UNIT-TEST :SUCCESSOR-FN-RABBIT-HOLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS #$Predicate) (#$isa ?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS #$VariableArityRelation) (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS) (#$forAll ?SEQ (#$implies (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS . ?SEQ) (#$thereExists ?SUCCESSOR (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS ?SUCCESSOR . ?SEQ))))) (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS ?THREE ?TWO ?ONE . ?SEQ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :MAX-TIME 60)) :EXPECTED-RESULT-TEST (QUOTE SUCCESSOR-FN-RABBIT-HOLE-BINDINGS-TEST) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Test that an infinitely recursive rule does not cause it to go down a rabbit hole
  1766. and get lost forever.  This test failed with :least-commitment and succeeds with
  1767. :shallow-and-cheap.")
  1768. ;;; Result(82)  <==== #<INFERENCE-UNIT-TEST 0>
  1769. ;;; CYC(83): (DEFINE-INFERENCE-UNIT-TEST :SUCCESSOR-FN-DEEP-RABBIT-HOLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS #$Predicate) (#$isa ?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS #$VariableArityRelation) (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS) (#$forAll ?SEQ (#$implies (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS . ?SEQ) (#$thereExists ?SUCCESSOR (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS ?SUCCESSOR . ?SEQ))))) (?DESCENDING-CONTIGUOUS-SERIES-OF-NATURAL-NUMBERS ?SIX ?FIVE ?FOUR ?THREE ?TWO ?ONE . ?SEQ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :MAX-TIME 212)) :EXPECTED-RESULT-TEST (QUOTE NOT-EQ) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Like @xref :successor-fn-rabbit-hole except deeper.")
  1770. ;;; Result(83)  <==== #<INFERENCE-UNIT-TEST 0>
  1771. ;;; CYC(84): (DEFINE-INFERENCE-UNIT-TEST :TOP-LEVEL-SENTENCE-DENOTING-VARIABLE-BACKCHAIN :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?MT #$Microtheory) (#$isa ?PRED #$UnaryPredicate) (#$ist ?MT (#$isa #$Thing #$Thing)) (#$implies (#$and (#$ist ?MT ?PROP) (#$equalSymbols ?PROP (#$isa #$Thing #$Thing))) (?PRED ?PROP))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT #$isa #$Thing #$Thing)))) :COMMENT "Backchaining involving a rule which would
  1772. yield a top-level sentence-denoting variable
  1773. which must be special-cased with #$trueSentence.")
  1774. ;;; Result(84)  <==== #<INFERENCE-UNIT-TEST 0>
  1775. ;;; CYC(85): (DEFINE-INFERENCE-UNIT-TEST :IRRELEVANT-DOES-NOT-IMPLY-PENDING :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$isa ?T #$UnaryPredicate) (#$implies (#$and (?P ?X) (?Q ?X)) (?S ?X)) (#$highlyRelevantAssertion (#$implies (#$and (?P ?X) (?Q ?X)) (?S ?X))) (#$implies (?T ?X) (?Q ?X)) (#$implies (?R ?X) (?S ?X)) (#$irrelevantAssertion (#$implies (?R ?X) (?S ?X))) (#$implies (?Q ?X) (?R ?X)) (?T "a")) (#$and (?S "a") (#$trueSubL (#$ExpandSubLFn (?T) (UNASSERT-HIGHLY-RELEVANT-MT-OF-SENTENCE (QUOTE (?T "a"))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "First it will try rule 1, and split it into (P a) and (Q a).  It will try (P a) first because
  1776. its productivity is zero which is smaller than 1.  In doing so it should deem the (Q a) problem
  1777. irrelevant, but not pending.  The inference engine used to deem the (Q a) problem pending, which was
  1778. causing problems.  Later it will use rules 2a and then 2b, which will reconnect it to the (Q a) problem.
  1779. If it were marked pending, it would not consider doing more work on the problem, but if were just marked
  1780. irrelevant and not pending, then it will become relevant again and the answer will come through.
  1781.  
  1782. The meta-assertions trick the tactician into doing the rules in the /wrong/ way, even after
  1783. the experience-based Tactician eventually learns the right way to solve this.
  1784. There's a diagram of this on Keith's whiteboard, near the middle, marked
  1785. :irrelevant-does-not-imply-pending.")
  1786. ;;; Result(85)  <==== #<INFERENCE-UNIT-TEST 0>
  1787. ;;; CYC(86): (DEFINE-INFERENCE-UNIT-TEST :IRRELEVANT-DOES-NOT-IMPLY-PENDING-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 1 ?A 2) (#$integerBetween ?A ?B 2) (#$different ?A 2) (#$different ?A 3) (#$different ?B 1) (#$different ?B 3)))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 0)) :EXPECTED-RESULT (QUOTE (((?A . 1) (?B . 2)))) :COMMENT "An attempt to redo :irrelevant-does-not-imply-pending without using backchains.")
  1788. ;;; Result(86)  <==== #<INFERENCE-UNIT-TEST 0>
  1789. ;;; CYC(87): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-PRAGMATIC-REQUIREMENT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?Q ?X)) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?Q ?OBJ)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test that requires a #$pragmaticRequirement to be answerable at all.")
  1790. ;;; Result(87)  <==== #<INFERENCE-UNIT-TEST 0>
  1791. ;;; CYC(88): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-PRAGMATIC-REQUIREMENT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$integerBetween 1 ?X 2) (?P ?X)) (#$pragmaticRequirement (#$unknownSentence (#$equalSymbols ?X 1)) (#$implies (#$integerBetween 1 ?X 2) (?P ?X)))) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 2)))) :COMMENT "Verify that #$unknownSentence can be used as a pragmaticRequirement.")
  1792. ;;; Result(88)  <==== #<INFERENCE-UNIT-TEST 0>
  1793. ;;; CYC(89): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-PRAGMATIC-REQUIREMENT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$nearestIsa ?X ?Y) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (#$pragmaticRequirement (?Q ?X) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?Q ?OBJ)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test that two pragmaticRequirements are implicitly conjoined.")
  1794. ;;; Result(89)  <==== #<INFERENCE-UNIT-TEST 0>
  1795. ;;; CYC(90): (DEFINE-INFERENCE-UNIT-TEST :MULTI-LITERAL-PRAGMATIC-REQUIREMENT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$isa ?T #$UnaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$and (#$isa ?X ?Y) (?R ?X) (?S ?X) (?T ?X)) (?P ?X ?Y)) (#$pragmaticRequirement (#$and (#$assertedSentence (?S ?X)) (#$knownSentence (?T ?X)) (#$nearestIsa ?X ?Y) (?Q ?X)) (#$implies (#$and (#$isa ?X ?Y) (?R ?X) (?S ?X) (?T ?X)) (?P ?X ?Y))) (?Q ?OBJ) (?R ?OBJ) (?S ?OBJ) (?T ?OBJ)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test that pragmaticRequirements work on rules with more
  1796. than one antecedent literal")
  1797. ;;; Result(90)  <==== #<INFERENCE-UNIT-TEST 0>
  1798. ;;; CYC(91): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-WITH-DONT-CARE-VAR :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?R #$BinaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?R ?X ??Z)) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?R ?OBJ #$Thing)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test that with a pragmaticRequirement mentioning
  1799. extra variables not in the rule, the extra variables are ignored
  1800. in inference.")
  1801. ;;; Result(91)  <==== #<INFERENCE-UNIT-TEST 0>
  1802. ;;; CYC(92): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-WITH-EXISTENTIAL :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?R #$BinaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$thereExists ??Z (#$and (#$nearestIsa ?X ?Y) (?R ?X ??Z))) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?R ?OBJ #$Thing)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test that with a pragmaticRequirement mentioning
  1803. extra variables not in the rule, the extra variables are ignored
  1804. in inference.")
  1805. ;;; Result(92)  <==== #<INFERENCE-UNIT-TEST 0>
  1806. ;;; CYC(93): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-WITH-SHARED-VAR :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?R #$BinaryPredicate) (#$isa ?S #$BinaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?R ?X ??Z) (?S ?X ??Z)) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?R ?OBJ #$Thing) (?S ?OBJ #$Thing)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?Y . #$Individual)))) :COMMENT "Test of a pragmaticRequirement with two conjuncts,
  1807. each mentioning the same variable which is not in the rule.
  1808. This one should be satisfiable.")
  1809. ;;; Result(93)  <==== #<INFERENCE-UNIT-TEST 0>
  1810. ;;; CYC(94): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-WITH-SHARED-VAR-UNSATISFIABLE :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?R #$BinaryPredicate) (#$isa ?S #$BinaryPredicate) (#$isa ?OBJ #$Individual) (#$implies (#$isa ?X ?Y) (?P ?X ?Y)) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?R ?X ?Z) (?S ?X ?Z)) (#$implies (#$isa ?X ?Y) (?P ?X ?Y))) (?R ?OBJ #$Individual) (?S ?OBJ #$Collection)) (#$thereExists ?X (?P ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Test of a pragmaticRequirement with two conjuncts,
  1811. each mentioning the same variable which is not in the rule.
  1812. This one should be unsatisfiable, but would have been
  1813. satisfiable if the two variables were treated as different
  1814. variables instead of as the same.")
  1815. ;;; Result(94)  <==== #<INFERENCE-UNIT-TEST 0>
  1816. ;;; CYC(95): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-ACROSS-MTS-IN-TWO-PARTS :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (#$forAll ?X (#$forAll ?Y (#$implies (#$isa ?X ?Y) (?P ?X ?Y)))))) (#$thereExists ?A (?P ?A ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$implies (#$and (#$isa ?OBJ #$Individual) (?Q ?OBJ) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?Q ?X)) (#$ist #$UniversalVocabularyMt (#$forAll ?X (#$forAll ?Y (#$implies (#$isa ?X ?Y) (?P ?X ?Y))))))) (#$thereExists ?A (?P ?A ?B)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL) :EXPECTED-RESULT (((?B . #$Individual)))))) :COMMENT "Test that requires a #$pragmaticRequirement to be answerable at all,
  1817. and makes sure the pragmaticRequirement can canonicalize across mts,
  1818. if the czer is spoon-fed via a followup query to avoid issues with variable scoping.")
  1819. ;;; Result(95)  <==== #<INFERENCE-UNIT-TEST 0>
  1820. ;;; CYC(96): (DEFINE-INFERENCE-UNIT-TEST :PRAGMATIC-REQUIREMENT-ACROSS-MTS :OWNER "jantos" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?OBJ #$Individual) (#$ist #$UniversalVocabularyMt (#$forAll ?X (#$forAll ?Y (#$implies (#$isa ?X ?Y) (?P ?X ?Y))))) (#$pragmaticRequirement (#$and (#$nearestIsa ?X ?Y) (?Q ?X)) (#$ist #$UniversalVocabularyMt (#$forAll ?X (#$forAll ?Y (#$implies (#$isa ?X ?Y) (?P ?X ?Y)))))) (?Q ?OBJ)) (#$thereExists ?A (?P ?A ?B))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?B . #$Individual)))) :COMMENT "Test that requires a #$pragmaticRequirement to be answerable at all,
  1821. and makes sure the pragmaticRequirement can canonicalize across mts.")
  1822. ;;; Result(96)  <==== #<INFERENCE-UNIT-TEST 0>
  1823. ;;; CYC(97): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-DONT-CARE-PRAGMATIC-REQUIREMENT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?LOGIC #$UnaryPredicate) (#$isa ?PROP #$UnaryPredicate) (#$isa ?PRAG #$BinaryPredicate) (#$implies (?LOGIC ?X) (?PROP ?X)) (#$pragmaticRequirement (#$and (?PRAG ?X ??ONE) (#$equalSymbols ??ONE 1)) (#$implies (?LOGIC ?X) (?PROP ?X))) (#$pragmaticRequirement (#$and (?PRAG ?X ??TWO) (#$equalSymbols ??TWO 2)) (#$implies (?LOGIC ?X) (?PROP ?X))) (?LOGIC 212) (?LOGIC 213) (?PRAG 212 1) (?PRAG 212 2)) (?PROP ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?TERM . 212)))) :COMMENT "Test that ensures that two #$pragmaticRequirements involving a don't care variable
  1824.    doesn't think they are the same variable when merging the requirements.")
  1825. ;;; Result(97)  <==== #<INFERENCE-UNIT-TEST 0>
  1826. ;;; CYC(98): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-PRAGMATIC-REQUIREMENT-WITH-EXISTENTIAL :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?LOGIC #$UnaryPredicate) (#$isa ?PROP #$UnaryPredicate) (#$isa ?PRAG #$BinaryPredicate) (#$implies (?LOGIC ?X) (?PROP ?X)) (#$pragmaticRequirement (#$thereExists ??ONE (#$and (?PRAG ?X ??ONE) (#$equalSymbols ??ONE 1))) (#$implies (?LOGIC ?X) (?PROP ?X))) (#$pragmaticRequirement (#$thereExists ??TWO (#$and (?PRAG ?X ??TWO) (#$equalSymbols ??TWO 2))) (#$implies (?LOGIC ?X) (?PROP ?X))) (?LOGIC 212) (?LOGIC 213) (?PRAG 212 1) (?PRAG 212 2)) (?PROP ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?TERM . 212)))) :COMMENT "Test that ensures that two #$pragmaticRequirements involving a don't care variable
  1827.    doesn't think they are the same variable when merging the requirements.")
  1828. ;;; Result(98)  <==== #<INFERENCE-UNIT-TEST 0>
  1829. ;;; CYC(99): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-EXCEPT-WHEN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?TERM #$Collection) (#$genls ?TERM #$Thing) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)) (#$exceptWhen (#$equals ?X ?Y) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)))) (?P ?TERM ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?COL . #$Thing)))) :COMMENT "Test that ensures that #$exceptWhen is correctly rejecting transformation proofs.")
  1830. ;;; Result(99)  <==== #<INFERENCE-UNIT-TEST 0>
  1831. ;;; CYC(100): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-EXCEPT-WHEN-RESIDUAL-TRANSFORMATION :OWNER "goolsbey" :BUG 21015 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?TERM #$Collection) (#$genls ?TERM #$Thing) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)) (#$exceptWhen (#$equals ?X ?Y) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)))) (#$and (?P ?TERM ?COL) (#$different ?COL ?P))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?COL . #$Thing)))) :COMMENT "Test that ensures that #$exceptWhen is correctly rejecting residual transformation proofs.")
  1832. ;;; Result(100)  <==== #<INFERENCE-UNIT-TEST 0>
  1833. ;;; CYC(101): (DEFINE-INFERENCE-UNIT-TEST :ALLOW-ABNORMALITY-CHECKING?-OBEYED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?TERM #$Collection) (#$genls ?TERM #$Thing) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)) (#$exceptWhen (#$equals ?X ?Y) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)))) (?P ?TERM ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ALLOW-ABNORMALITY-CHECKING? NIL :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?COL . #$Thing)) ((?COL . ?TERM)))) :COMMENT "Test that ensures that #$exceptWhen does _not_ reject transformation proofs
  1834. when :allow-abnormality-checking? is specified to be NIL.  This is the dual of
  1835. :simple-except-when.")
  1836. ;;; Result(101)  <==== #<INFERENCE-UNIT-TEST 0>
  1837. ;;; CYC(102): (DEFINE-INFERENCE-UNIT-TEST :PARTIAL-EXCEPT-WHEN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?TERM #$Collection) (#$genls ?TERM #$Thing) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)) (#$exceptWhen (#$equals ?Y ?TERM) (#$implies (#$genls ?X ?Y) (?P ?X ?Y)))) (?P ?TERM ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?COL . #$Thing)))) :COMMENT "Test that ensures that an #$exceptWhen that is only based on some of the variables in a rule are working.")
  1838. ;;; Result(102)  <==== #<INFERENCE-UNIT-TEST 0>
  1839. ;;; CYC(103): (DEFINE-INFERENCE-UNIT-TEST :VARIABLE-MAP-EXCEPT-WHEN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$VariableArityRelation) (#$isa ?P #$Predicate) (#$isa ?TERM #$Collection) (#$genls ?TERM #$Thing) (#$implies (#$and (#$genls ?X ?Y) (#$different ?E ?C)) (?P ?X ?Y ?A ?B ?C ?D ?E ?F)) (#$exceptWhen (#$and (#$equals ?Y ?TERM) (#$equals ?A 1) (#$equals ?B 2) (#$equals ?C 3) (#$equals ?D 4) (#$equals ?E 5) (#$equals ?F 6)) (#$implies (#$and (#$genls ?X ?Y) (#$different ?E ?C)) (?P ?X ?Y ?A ?B ?C ?D ?E ?F)))) (?P ?TERM ?COL 1 2 3 4 5 6)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?COL . #$Thing)))) :COMMENT "Test that ensures we correctly order the variables before doing an abnormality check")
  1840. ;;; Result(103)  <==== #<INFERENCE-UNIT-TEST 0>
  1841. ;;; CYC(104): (DEFINE-INFERENCE-UNIT-TEST :PROOF-CHECKER-MODE-WITH-RULE-FORBIDDEN :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$backchainRequired ?Q) (?P "a")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOWED-RULES NIL)) :EXPECTED-RESULT NIL :COMMENT "Test that proof-checker mode will cause the expected
  1842. answer to be inhibited if no rules are allowed.
  1843. This is like @xref :simple-backchain-required but
  1844. with no :allowed-rules.")
  1845. ;;; Result(104)  <==== #<INFERENCE-UNIT-TEST 0>
  1846. ;;; CYC(105): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-DEPTH-EXTENSION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-0 #$UnaryPredicate) (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?PRED-2 #$UnaryPredicate) (#$implies (?PRED-1 ?OBJ) (?PRED-0 ?OBJ)) (#$implies (?PRED-2 ?OBJ) (?PRED-1 ?OBJ)) (?PRED-0 0) (?PRED-1 1) (?PRED-2 2)) (?PRED-0 ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 0)) :EXPECTED-RESULT (QUOTE (((?X . 0)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 1) :EXPECTED-RESULT (((?X . 1))) :EXPECTED-HALT-REASON :EXHAUST) (:PROPERTIES (:CONTINUABLE? NIL :MAX-TRANSFORMATION-DEPTH 2) :EXPECTED-RESULT (((?X . 2))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to ensure that continuation with increasing values for :max-transformation-depth
  1847.    causes proper reconsideration of set-aside problems.")
  1848. ;;; Result(105)  <==== #<INFERENCE-UNIT-TEST 0>
  1849. ;;; CYC(106): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-LINK-REUSE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-0 #$UnaryPredicate) (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?PRED-2 #$UnaryPredicate) (#$implies (?PRED-1 ?OBJ) (?PRED-0 ?OBJ)) (#$implies (?PRED-2 ?OBJ) (?PRED-1 ?OBJ)) (?PRED-0 0) (?PRED-1 1) (?PRED-2 2)) (?PRED-0 ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 0)) :EXPECTED-RESULT (QUOTE (((?X . 0)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :PREVIOUS :PROPERTIES (:CONTINUABLE? NIL :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1) :EXPECTED-RESULT (((?X . 0)) ((?X . 1)))) (:SENTENCE :PREVIOUS :PROPERTIES (:CONTINUABLE? NIL :MAX-TRANSFORMATION-DEPTH 2) :EXPECTED-RESULT (((?X . 0)) ((?X . 1)) ((?X . 2)))))) :COMMENT "Test to ensure that a new inference in the same store with an increased values for :max-transformation-depth
  1850.    correctly reuses the existing transformation link created by the previous inference.")
  1851. ;;; Result(106)  <==== #<INFERENCE-UNIT-TEST 0>
  1852. ;;; CYC(107): (DEFINE-INFERENCE-UNIT-TEST :SET-ASIDE-PENDING-NO-GOOD :OWNER "goolsbey" :BUG 4554 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?HAS-ATTRIBUTES #$BinaryPredicate) (#$isa ?BRITNEY-SPEARS #$Individual) (#$isa ?PRETTY #$Individual)) (?HAS-ATTRIBUTES ?BRITNEY-SPEARS ?PRETTY)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-NUMBER 1)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? NIL :MAX-TRANSFORMATION-DEPTH 1 :MAX-NUMBER 1) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test to make sure that a PENDING-NO-GOOD problem
  1853. which is set aside doesn't error when becoming possible again.")
  1854. ;;; Result(107)  <==== #<INFERENCE-UNIT-TEST 0>
  1855. ;;; CYC(108): (DEFINE-INFERENCE-UNIT-TEST :SET-ASIDE-PENDING-NO-GOOD-TO-POSSIBLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?HAS-ATTRIBUTES #$BinaryPredicate) (#$isa ?BRITNEY-SPEARS #$Individual) (#$isa ?PRETTY #$Individual) (#$forAll ?X (#$implies (#$isa ?X #$Individual) (?HAS-ATTRIBUTES ?X ?PRETTY)))) (?HAS-ATTRIBUTES ?BRITNEY-SPEARS ?PRETTY)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :CONTINUABLE? T :MAX-NUMBER 1)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:PROPERTIES (:CONTINUABLE? NIL :MAX-TRANSFORMATION-DEPTH 1 :MAX-NUMBER 1) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :MAX-NUMBER))) :COMMENT "Test to make sure that a PENDING-NO-GOOD problem
  1856. can actually become strategically good when continued.")
  1857. ;;; Result(108)  <==== #<INFERENCE-UNIT-TEST 0>
  1858. ;;; CYC(109): (DEFINE-INFERENCE-UNIT-TEST :TRUE-SENTENCE-IMPLIES-VAR-CANONICALIZATION :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) (#$assertionDirection (#$implies (?PRED ?EXP ?EXPND) (#$trueSentence ?EXPND)) #$Forward-AssertionDirection) (?PRED (#$isa #$Thing #$Thing) (#$forAll ?IMP-X (#$implies (?P ?IMP-X) (?Q ?IMP-X)))) (?P #$Thing)) (?Q #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Checks whether a rule which concludes (#$trueSentence (#$implies (P ?IMP-X) (Q ?IMP-X))), (Q something) is concluded when (P something) is asserted. Also ?IMP-X variable binding is preserved (it should be, but earlier it didnt).")
  1859. ;;; Result(109)  <==== #<INFERENCE-UNIT-TEST 0>
  1860. ;;; CYC(110): (DEFINE-INFERENCE-UNIT-TEST :EXCEPTION-TMS-BACKWARD :OWNER "goolsbey" :WORKING? NIL :BUG 5961 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?FLY #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$isa ?BIRD #$Collection)) (#$ist #$UniversalVocabularyMt (#$genls ?BIRD #$Individual)) (#$ist #$UniversalVocabularyMt (#$isa ?PENGUIN #$Collection)) (#$ist #$UniversalVocabularyMt (#$genls ?PENGUIN ?BIRD)) (#$ist #$BaseKB (#$forAll ?OBJ (#$implies (#$isa ?OBJ ?BIRD) (?FLY ?OBJ)))) (#$isa ?OPUS ?PENGUIN)) (?FLY ?OPUS)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :CACHE-INFERENCE-RESULTS? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$implies (#$ist #$BaseKB (#$forAll ?OBJ (#$exceptWhen (#$isa ?OBJ ?PENGUIN) (#$implies (#$isa ?OBJ ?BIRD) (?FLY ?OBJ))))) (#$ist #$EverythingPSC (?FLY ?OPUS)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :PROBLEM-STORE NIL) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST))) :COMMENT "Checks to make sure that the addition of an exception triggers TMS over already
  1861.    cached deductions involving the rule, removing any that are now exceptions.")
  1862. ;;; Result(110)  <==== #<INFERENCE-UNIT-TEST 0>
  1863. ;;; CYC(111): (DEFINE-INFERENCE-UNIT-TEST :EXCEPTION-TMS-BACKWARD-NO-OP :OWNER "goolsbey" :BUG 5961 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?FLY #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$isa ?BIRD #$Collection)) (#$ist #$UniversalVocabularyMt (#$genls ?BIRD #$Individual)) (#$ist #$UniversalVocabularyMt (#$isa ?PENGUIN #$Collection)) (#$ist #$UniversalVocabularyMt (#$genls ?PENGUIN ?BIRD)) (#$ist #$BaseKB (#$forAll ?OBJ (#$implies (#$isa ?OBJ ?BIRD) (?FLY ?OBJ)))) (#$isa ?OPUS ?PENGUIN)) (?FLY ?OPUS)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :CACHE-INFERENCE-RESULTS? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$implies (#$ist #$BaseKB (#$forAll ?OBJ (#$exceptWhen (#$equals ?OBJ ?PENGUIN) (#$implies (#$isa ?OBJ ?BIRD) (?FLY ?OBJ))))) (#$ist #$EverythingPSC (?FLY ?OPUS)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T :PROBLEM-STORE NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Checks to make sure that the addition of an exception does not
  1864. remove any cached deductions that are ought not be excepted.  This is
  1865. the dual of @xref :exception-tms-backward; the only difference is that
  1866. in this test, the exception does not apply.")
  1867. ;;; Result(111)  <==== #<INFERENCE-UNIT-TEST 0>
  1868. ;;; CYC(112): (DEFINE-INFERENCE-UNIT-TEST :UNBOUND-PREDICATE-TACTIC-GETS-THROWN-AWAY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?PRED #$UnaryPredicate) (?PRED ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-UNBOUND-PREDICATE-TRANSFORMATION? NIL :CONTINUABLE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Query in which a problem should only have unbound predicate
  1869.    transformation tactics on it, which should lead to it being
  1870.    thrown-away rather than set-aside, which in turn distinguishes
  1871.    :EXHAUST from :EXHAUST-TOTAL.")
  1872. ;;; Result(112)  <==== #<INFERENCE-UNIT-TEST 0>
  1873. ;;; CYC(113): (DEFINE-INFERENCE-UNIT-TEST :META-TRANSFORMATION-TACTIC-THROWN-AWAY :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?COL #$Collection) (#$isa ?X ?COL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ALLOW-HL-PREDICATE-TRANSFORMATION? NIL :ALLOW-UNBOUND-PREDICATE-TRANSFORMATION? NIL :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "The meta-transformation tactic should be thrown away, which allows for
  1874.    the inference to be deemed exhaust-total.")
  1875. ;;; Result(113)  <==== #<INFERENCE-UNIT-TEST 0>
  1876. ;;; CYC(114): (DEFINE-INFERENCE-UNIT-TEST :CIRCULAR-PROOFS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$implies (?Q ?X) (?P ?X)) (?Q 212)) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RESULT-UNIQUENESS :PROOF :MAX-TRANSFORMATION-DEPTH 2)) :EXPECTED-RESULT (QUOTE (((?WHAT . 212)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (= 1 (PROBLEM-STORE-REJECTED-PROOF-COUNT (CURRENTLY-ACTIVE-PROBLEM-STORE)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that verifies that a circular proof of (P 212) gets rejected.")
  1877. ;;; Result(114)  <==== #<INFERENCE-UNIT-TEST 0>
  1878. ;;; CYC(115): (PROGN (DEFINE-PRIVATE DONT-REMOVE-PREDICATE-HELPER (STORE PREDICATE) (CLET ((FIRST-INFERENCE (FIND-INFERENCE-BY-ID STORE 0)) (PROOF-MT (FIRST (INFERENCE-HL-MTS FIRST-INFERENCE))) (PROBLEM (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$ist PROOF-MT (BQ-CONS PREDICATE (QUOTE (?X))))))) (PWHEN PROBLEM (RET (CNOT (PROBLEM-HAS-TACTIC-OF-TYPE-WITH-STATUS? PROBLEM :REMOVAL :EXECUTED)))))) (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-DONT-REMOVE-B :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?C ?X) (?A ?X)) (#$implies (?D ?X) (?B ?X)) (?A 1) (?B 2) (?B 3) (?B 4) (?C 5) (?D 1)) (#$and (#$integerBetween 1 1 ?WHAT) (?A ?WHAT) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (DONT-REMOVE-PREDICATE-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?B)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Query in which a better tactician should not blindly run removals on B."))
  1879. ;;; Result(115)  <==== #<INFERENCE-UNIT-TEST 0>
  1880. ;;; CYC(116): (DEFINE-INFERENCE-UNIT-TEST :DONT-REMOVE-D :OWNER "goolsbey" :BUG 10716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?C ?X) (?A ?X)) (#$implies (?D ?X) (?B ?X)) (?A 1) (?A 10) (?A 11) (?A 12) (?A 13) (?B 20) (?B 21) (?B 22) (?B 23) (?B 24) (?B 25) (?C 30) (?D 1) (?D 40) (?D 41) (?D 42) (?D 43) (?D 44) (?D 45)) (#$and (?A ?WHAT) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T :ALLOWED-MODULES (:NOT :JOIN))) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (DONT-REMOVE-PREDICATE-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?D)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Query in which a better tactician should not blindly run removals on D.
  1881.    This requires the introduction of (#$and (?A ?X)(?D ?X))")
  1882. ;;; Result(116)  <==== #<INFERENCE-UNIT-TEST 0>
  1883. ;;; CYC(117): (DEFINE-INFERENCE-UNIT-TEST :DONT-REMOVE-D-3WAY :OWNER "goolsbey" :BUG 10716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?D ?X) (?B ?X)) (?A 1) (?B 2) (?B 3) (?B 4) (?D 1) (?D 5) (?D 6) (?D 7)) (#$and (#$integerBetween 1 1 ?WHAT) (?A ?WHAT) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (DONT-REMOVE-PREDICATE-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?D)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Query in which a better tactician should not blindly run removals on D.
  1884.    This requires the introduction of (#$and (#$integerBetween 1 1 ?X)(?A ?X)(?D ?X))")
  1885. ;;; Result(117)  <==== #<INFERENCE-UNIT-TEST 0>
  1886. ;;; CYC(118): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-TRIGGER-RESTRICTION :OWNER "goolsbey" :BUG 10716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$BinaryPredicate) (#$isa ?B #$BinaryPredicate) (#$isa ?C #$BinaryPredicate) (#$isa ?D #$BinaryPredicate) (#$isa ?YES #$Individual) (#$isa ?NO #$Individual) (#$backchainForbidden ?A) (#$backchainForbidden ?C) (#$backchainForbidden ?D) (#$implies (?D ??WHATEVER ?X) (?B ?YES ?X)) (?A ?YES 1) (?A ?YES 12) (?A ?YES 13) (?A ?YES 14) (?A ?YES 15) (?B ?NO 1) (?B ?NO 22) (?B ?NO 23) (?B ?NO 24) (?B ?NO 25) (?B ?NO 26) (?C ?YES 1) (?C ?NO 32) (?C ?NO 33) (?C ?NO 34) (?C ?NO 35) (?C ?NO 36) (?D ?YES 1) (?D ?YES 42) (?D ?YES 43) (?D ?YES 44) (?D ?YES 45) (?D ?YES 46)) (#$and (?A ?X ?Y) (?B ?X ?Y) (?C ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? NIL :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?YES) (?Y . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "The proof we want has no natural path to bubble up via restriction links,
  1887. so when it tries to bubble up the residual transformation link, we need to
  1888. trigger the creation of an appropriate restriction link.")
  1889. ;;; Result(118)  <==== #<INFERENCE-UNIT-TEST 0>
  1890. ;;; CYC(119): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-TRIGGER-RESTRICTION-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?C #$UnaryPredicate) (#$isa ?M #$UnaryPredicate) (#$isa ?A #$UnaryPredicate) (#$implies (#$and (?M ?CONCENTRATION) (?A ?KA) (#$evaluate ?ANSWER (#$PlusFn ?CONCENTRATION ?KA))) (?C ?ANSWER)) (?M 1) (?A 2)) (#$thereExists ?X (#$and (?C ?X) (#$evaluate ?FINAL-ANSWER (#$TimesFn ?X 2))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T)) :EXPECTED-RESULT (QUOTE (((?FINAL-ANSWER . 6)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Distilled from (#$TestQueryFn #$HaloPilotChallenge-DA13a)")
  1891. ;;; Result(119)  <==== #<INFERENCE-UNIT-TEST 0>
  1892. ;;; CYC(120): (DEFINE-INFERENCE-UNIT-TEST :DONT-CREATE-IDENTICAL-RESIDUAL-TRANSFORMATION-LINKS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$BinaryPredicate) (#$implies (?P ?A ?B) (?Q ?B ?A)) (?P 1 2)) (#$and (?Q ?X ?Y) (?Q ?Y ?X))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T :BROWSABLE? T)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (= 3 (PROBLEM-STORE-RESIDUAL-TRANSFORMATION-LINK-COUNT (CURRENTLY-ACTIVE-PROBLEM-STORE)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "We should find-or-create residual transformation links, not just blindly
  1893. create them.  If we blindly created them, we would have more than 2 residual transformation
  1894. links in this store.")
  1895. ;;; Result(120)  <==== #<INFERENCE-UNIT-TEST 0>
  1896. ;;; CYC(121): (PROGN (DEFINE RESIDUAL-TRANSFORMATION-LOOP-HELPER (STORE PREDICATE) (PWHEN (= 1 (PROBLEM-STORE-RESIDUAL-TRANSFORMATION-LINK-COUNT STORE)) (CLET ((RT-LINK (PROBLEM-STORE-FIRST-LINK-OF-TYPE STORE :RESIDUAL-TRANSFORMATION)) (RESIDUAL-PROBLEM (RESIDUAL-TRANSFORMATION-LINK-RESIDUAL-PROBLEM RT-LINK)) (SUPPORTING-PROBLEM (RESIDUAL-TRANSFORMATION-LINK-SUPPORTING-PROBLEM RT-LINK))) (PWHEN (EQ SUPPORTING-PROBLEM RESIDUAL-PROBLEM) (CLET ((ASENT (SINGLE-LITERAL-PROBLEM-ATOMIC-SENTENCE RESIDUAL-PROBLEM))) (PWHEN (EQ PREDICATE (ATOMIC-SENTENCE-PREDICATE ASENT)) (RET T))))))) (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-LOOP :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?B #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?D ?X) (?B ?X)) (?B 2) (?D 1) (?D 5)) (#$and (?B ?WHAT) (?D ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)) ((?WHAT . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (RESIDUAL-TRANSFORMATION-LOOP-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?D)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Query that ensures that a residual transformation link, if added, would be between
  1897.    (?D ?X) and (#$and (?D ?X) (?D ?X)) which would simplify to (?D ?X) and be a loop."))
  1898. ;;; Result(121)  <==== #<INFERENCE-UNIT-TEST 0>
  1899. ;;; CYC(122): (PROGN (DEFINE-PRIVATE RESIDUAL-TRANSFORMATION-PROBLEM-REUSE-HELPER-1 (STORE MT PRED-A PRED-B PRED-C PRED-D PRED-E) (IGNORE PRED-B PRED-C) (PWHEN (CAND (= 2 (PROBLEM-STORE-RESIDUAL-TRANSFORMATION-LINK-COUNT STORE)) (= 4 (PROBLEM-STORE-INFERENCE-COUNT STORE))) (CLET ((STRATEGY-FOR-EB (SIMPLEST-INFERENCE-STRATEGY (FIND-INFERENCE-BY-ID STORE 1))) (STRATEGY-FOR-AB (SIMPLEST-INFERENCE-STRATEGY (FIND-INFERENCE-BY-ID STORE 2))) (PROBLEM-D (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-CONS PRED-D (QUOTE (?X))) MT)) (PROBLEM-AD (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$and (BQ-CONS PRED-A (QUOTE (?X))) (BQ-CONS PRED-D (QUOTE (?X)))) MT)) (PROBLEM-ED (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$and (BQ-CONS PRED-E (QUOTE (?X))) (BQ-CONS PRED-D (QUOTE (?X)))) MT))) (PWHEN (CAND STRATEGY-FOR-EB STRATEGY-FOR-AB PROBLEM-D PROBLEM-AD PROBLEM-ED) (PWHEN (CAND (= 2 (PROBLEM-ARGUMENT-LINK-COUNT PROBLEM-D)) (= 1 (PROBLEM-DEPENDENT-LINK-COUNT PROBLEM-AD)) (= 1 (PROBLEM-DEPENDENT-LINK-COUNT PROBLEM-ED))) (PWHEN (CAND (CAND (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-ED) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-D)) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-AD))) (CAND (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-AD) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-D)) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-ED)))) (RET T))))))) (DEFINE-PRIVATE RESIDUAL-TRANSFORMATION-PROBLEM-REUSE-HELPER-2 (STORE MT PRED-A PRED-B PRED-C PRED-D PRED-E) (IGNORE PRED-B PRED-C) (PWHEN (CAND (= 3 (PROBLEM-STORE-RESIDUAL-TRANSFORMATION-LINK-COUNT STORE)) (= 6 (PROBLEM-STORE-INFERENCE-COUNT STORE))) (CLET ((STRATEGY-FOR-EB (SIMPLEST-INFERENCE-STRATEGY (FIND-INFERENCE-BY-ID STORE 1))) (STRATEGY-FOR-AB (SIMPLEST-INFERENCE-STRATEGY (FIND-INFERENCE-BY-ID STORE 2))) (STRATEGY-FOR-AC (SIMPLEST-INFERENCE-STRATEGY (FIND-INFERENCE-BY-ID STORE 4))) (PROBLEM-D (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-CONS PRED-D (QUOTE (?X))) MT)) (PROBLEM-AD (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$and (BQ-CONS PRED-A (QUOTE (?X))) (BQ-CONS PRED-D (QUOTE (?X)))) MT)) (PROBLEM-ED (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$and (BQ-CONS PRED-E (QUOTE (?X))) (BQ-CONS PRED-D (QUOTE (?X)))) MT))) (PWHEN (CAND STRATEGY-FOR-EB STRATEGY-FOR-AB STRATEGY-FOR-AC PROBLEM-D PROBLEM-AD PROBLEM-ED) (PWHEN (CAND (= 2 (PROBLEM-ARGUMENT-LINK-COUNT PROBLEM-D)) (= 2 (PROBLEM-DEPENDENT-LINK-COUNT PROBLEM-AD)) (= 1 (PROBLEM-DEPENDENT-LINK-COUNT PROBLEM-ED))) (PWHEN (CAND (CAND (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-ED) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-D)) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-EB PROBLEM-AD))) (CAND (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-AD) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-D)) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AB PROBLEM-ED))) (CAND (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AC PROBLEM-AD) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AC PROBLEM-D)) (CNOT (RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY-FOR-AC PROBLEM-ED)))) (RET T))))))) (DEFINE-PRIVATE RTPRH-PROBLEM-MOTIVATED-WRT-REMOVAL? (STRATEGY PROBLEM) (PCOND ((BALANCED-STRATEGY-P STRATEGY) (RET (BALANCED-STRATEGY-PROBLEM-MOTIVATED-WRT-REMOVAL? STRATEGY PROBLEM))) ((BALANCING-TACTICIAN-P STRATEGY) (RET (PROBLEM-MOTIVATED? PROBLEM (BALANCING-TACTICIAN-SOLE-REMOVAL-SUBSTRATEGY STRATEGY)))) (T (RET (ERROR "Unexpected strategy type ~a" STRATEGY))))) (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-PROBLEM-REUSE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$isa ?E #$UnaryPredicate) (#$implies (?D ?X) (?B ?X)) (#$implies (?D ?Y) (?C ?Y)) (?A "yes") (?B 1) (?B 2) (?B 3) (?B 4) (?C 11) (?C 12) (?C 13) (?C 14) (?D "yes") (?D 1) (?D 2) (?D 3) (?D 4) (?E "no")) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$EverythingPSC (#$and (?E ?WHAT) (?B ?WHAT))) :EXPECTED-RESULT NIL :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T :ALLOWED-MODULES (:NOT :JOIN))) (:SENTENCE (#$ist #$EverythingPSC (#$and (?A ?WHAT) (?B ?WHAT))) :EXPECTED-RESULT (((?WHAT . "yes"))) :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T :ALLOWED-MODULES (:NOT :JOIN))) (:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (RESIDUAL-TRANSFORMATION-PROBLEM-REUSE-HELPER-1 (CURRENTLY-ACTIVE-PROBLEM-STORE) #$EverythingPSC ?A ?B ?C ?D ?E)))) :PROPERTIES (:CONTINUABLE? NIL :BROWSABLE? T) :EXPECTED-RESULT (NIL)) (:SENTENCE (#$ist #$EverythingPSC (#$and (?A ?WHAT) (?C ?WHAT))) :EXPECTED-RESULT (((?WHAT . "yes"))) :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T :ALLOWED-MODULES (:NOT :JOIN))) (:SENTENCE (#$ist #$EverythingPSC (#$trueSubL (#$SubLQuoteFn (RESIDUAL-TRANSFORMATION-PROBLEM-REUSE-HELPER-2 (CURRENTLY-ACTIVE-PROBLEM-STORE) #$EverythingPSC ?A ?B ?C ?D ?E)))) :PROPERTIES (:CONTINUABLE? NIL) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that used to ensure that
  1900.    (a) RT links can motivate more than one JO/T pair
  1901.    (b) new motivation can be added to an existing RT link
  1902.    (c) RT is only propagated to strategically motivated RT links
  1903.    back before *better-residual-transformation?*.
  1904.  
  1905.    Now, it verifies the expectations of the number of RT links added to the store,
  1906.    and make sure that R does not flow to irrelevant residual conjunction problems."))
  1907. ;;; Result(122)  <==== #<INFERENCE-UNIT-TEST 0>
  1908. ;;; CYC(123): (DEFINE-INFERENCE-UNIT-TEST :CONJUNCTIVE-REMOVAL-AFTER-RESIDUAL-TRANSFORMATION :OWNER "goolsbey" :BUG 12375 :KB :BOTH :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?HIGH #$Collection) (#$genls ?HIGH #$Individual) (#$isa ?MED #$Collection) (#$genls ?MED ?HIGH) (#$isa ?LOW #$Collection) (#$genls ?LOW ?MED) (#$isa ?PRED #$BinaryPredicate) (#$implies (#$genls ?X ?Y) (?PRED ?X ?Y))) (#$thereExists ?M (#$and (#$isa ?M #$Thing) (?PRED ?LOW ?M) (#$genls ?M ?HIGH)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOWED-MODULES (:NOT (:OR :REMOVAL-ALL-GENLS :REMOVAL-ALL-SPECS :REMOVAL-SUPERSET :REMOVAL-ALL-INSTANCES)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that a conjunctive removal after a residual transformation generates
  1909.    proofs that will bubble up to the original conjunction.")
  1910. ;;; Result(123)  <==== #<INFERENCE-UNIT-TEST 0>
  1911. ;;; CYC(124): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-WITH-TRANSFORMATION-BINDING :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$TernaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?PRED-D #$TernaryPredicate) (#$isa ?TERM-1 #$Thing) (#$isa ?TERM-2 #$Thing) (#$isa ?TERM-3 #$Thing) (#$implies (?PRED-D ?TERM-1 ?T ?TERM-3) (?PRED-B ?TERM-1 ?T ?TERM-3)) (?PRED-A ?TERM-1 ?TERM-2) (?PRED-D ?TERM-1 ?TERM-2 ?TERM-3) (?PRED-C ?TERM-2 ?TERM-3) (?PRED-C "c1" "c1") (?PRED-C "c2" "c2") (?PRED-C "c3" "c3") (?PRED-A "a1" ?TERM-2) (?PRED-A "a2" ?TERM-2) (?PRED-A "a3" ?TERM-2) (?PRED-A "a4" ?TERM-2) (?PRED-B "b1" ?TERM-2 ?TERM-3) (?PRED-B "b2" ?TERM-2 ?TERM-3) (?PRED-B "b3" ?TERM-2 ?TERM-3) (?PRED-B "b4" ?TERM-2 ?TERM-3) (?PRED-B "b5" ?TERM-2 ?TERM-3) (?PRED-B "b6" ?TERM-2 ?TERM-3) (?PRED-A ?TERM-1 "a1") (?PRED-A ?TERM-1 "a2") (?PRED-A ?TERM-1 "a3") (?PRED-A ?TERM-1 "a4") (?PRED-A ?TERM-1 "a5") (?PRED-D ?TERM-1 "d1" ?TERM-3) (?PRED-D ?TERM-1 "d2" ?TERM-3) (?PRED-D ?TERM-1 "d1" ?TERM-3) (?PRED-D ?TERM-1 "d4" ?TERM-3)) (#$thereExists ?X (#$thereExists ?Y (#$thereExists ?Z (#$and (?PRED-A ?X ?Y) (?PRED-B ?X ?Y ?Z) (?PRED-C ?Y ?Z)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that the pieces of a residual transformation proof
  1912.    under a transformation link with transformation bindings
  1913.    will bubble up to the original conjunction.")
  1914. ;;; Result(124)  <==== #<INFERENCE-UNIT-TEST 0>
  1915. ;;; CYC(125): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-WITH-TRANSFORMATION-BINDING-TO-SPLIT :OWNER "goolsbey" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?GL #$BinaryPredicate) (#$isa ?GE #$BinaryPredicate) (#$isa ?N #$BinaryPredicate) (#$isa ?A #$Individual) (#$implies (?N ?A ?X) (?P ?A ?X)) (?N ?A "x1") (?GL ?A "y1") (?GE ?A "z1") (?P "chaff1" "chaff1") (?P "chaff2" "chaff2") (?P "chaff3" "chaff3") (?P "chaff4" "chaff4") (?GE "chaff1" "chaff1") (?GE "chaff2" "chaff2") (?GE "chaff3" "chaff3") (?GE "chaff4" "chaff4")) (#$thereExists ?PV (#$and (?P ?PV ?X) (?GL ?PV ?Y) (?GE ?PV ?Z)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . "x1") (?Y . "y1") (?Z . "z1")))) :COMMENT "Test that ensures that the pieces of a residual transformation proof
  1916.    under a transformation link with transformation bindings that results in a split
  1917.    will bubble up to the original conjunction.
  1918.    This unit test was painfully distilled from the (#$TestQueryFn #$GLF-ArcsAndLabelsForPoisoningScript) query.")
  1919. ;;; Result(125)  <==== #<INFERENCE-UNIT-TEST 0>
  1920. ;;; CYC(126): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-EARLY-REMOVAL :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$integerBetween 1 ?X 212) (?P ?X))) (#$and (#$equalSymbols ?WHAT 42) (?P ?WHAT))))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :JOIN) :MAX-TRANSFORMATION-DEPTH 1 :MAX-PROBLEM-COUNT 16)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :COMMENT "Query in which a better tactician should perform an early removal to provide focus,
  1921. and should never backchain on (?P ?WHAT), only on (?P 42).")
  1922. ;;; Result(126)  <==== #<INFERENCE-UNIT-TEST 0>
  1923. ;;; CYC(127): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-EARLY-REMOVAL-RELATIVE-COMPLETENESS :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (#$integerBetween 1 ?X 212) (?P ?X)) (?Q 42)) (#$and (?P ?WHAT) (?Q ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :MAX-TRANSFORMATION-DEPTH 1 :MAX-PROBLEM-COUNT 16)) :EXPECTED-RESULT (QUOTE (((?WHAT . 42)))) :EXPECTED-HALT-REASON :MAX-PROBLEM-COUNT :COMMENT "Like :better-tactician-early-removal, except it doesn't have as many hints
  1924.  with respect to completeness and backchainForbidden.  It needs to know that
  1925.  (?Q :not-fully-bound) is 'as complete as' (?Q :fully-bound).  But at the very
  1926.  least, it ought to try backchaining on (?P 42) before backchaining on (?P ?WHAT).
  1927.  It ought NOT ever execute a removal tactic on (?P 42).")
  1928. ;;; Result(127)  <==== #<INFERENCE-UNIT-TEST 0>
  1929. ;;; CYC(128): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-COMPLETE-GENERATE-AND-TEST :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$and (#$constantName ?A "pred-A2") (#$constantName ?B "pred-B2") (#$constantName ?C "pred-C2") (#$constantName ?D "pred-D2")) (#$implies (?C ?X) (?A ?X)) (#$implies (?D ?X) (?B ?X)) (?A 1) (?A 0) (?B 1) (?B 0)) (#$and (#$integerBetween 1 ?WHAT 1) (?A ?WHAT) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$and (#$trueSubL (#$SubLQuoteFn (CLET ((CURRENT-STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (PREVIOUS-INFERENCE (FIND-INFERENCE-BY-ID CURRENT-STORE 0)) (PROOF-MT (FIRST (INFERENCE-HL-MTS PREVIOUS-INFERENCE))) (PROBLEM (FIND-PROBLEM-BY-EL-QUERY CURRENT-STORE (BQ-LIST* #$ist PROOF-MT (QUOTE ((?A ?X))))))) (PWHEN PROBLEM (CNOT (PROBLEM-HAS-TACTIC-OF-TYPE-WITH-STATUS? PROBLEM :REMOVAL :EXECUTED)))))) (#$trueSubL (#$SubLQuoteFn (CLET ((CURRENT-STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (PREVIOUS-INFERENCE (FIND-INFERENCE-BY-ID CURRENT-STORE 0)) (PROOF-MT (FIRST (INFERENCE-HL-MTS PREVIOUS-INFERENCE))) (PROBLEM (FIND-PROBLEM-BY-EL-QUERY CURRENT-STORE (BQ-LIST* #$ist PROOF-MT (QUOTE ((?B ?X))))))) (PWHEN PROBLEM (CNOT (PROBLEM-HAS-TACTIC-OF-TYPE-WITH-STATUS? PROBLEM :REMOVAL :EXECUTED)))))))) :PROPERTIES (:CONTINUABLE? T) :EXPECTED-RESULT (NIL)))) :COMMENT "Query in which a better tactician _should_ execute the complete tactic first,
  1930.  because it's cheap enough to do so, and should never execute any removal tactics on (?A ?X) or (?B ?X).")
  1931. ;;; Result(128)  <==== #<INFERENCE-UNIT-TEST 0>
  1932. ;;; CYC(129): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-COMPLETE-BUT-TOO-EXPENSIVE :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?C ?X) (?A ?X)) (#$implies (?D ?X) (?B ?X)) (?A 1) (?A 0) (?B 1) (?B 0)) (#$and (#$integerBetween 1 ?WHAT 212) (?A ?WHAT) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :MAX-PROBLEM-COUNT 212)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Query in which a better tactician should not execute the expensive complete tactic first,
  1933.  and furthermore should not later backtrack to run it.")
  1934. ;;; Result(129)  <==== #<INFERENCE-UNIT-TEST 0>
  1935. ;;; CYC(130): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-POWERSET-BACKCHAIN-ORDER-REQUIRED :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$BinaryPredicate) (?P 0 212) (?Q 0 212) (?P "interference" 1) (?P "interference" 2) (?P "interference" 3) (?P "interference" 4) (?P "interference" 5) (#$implies (#$equalSymbols ?Y 212) (?P 1 ?Y)) (#$implies (#$different ?Y 42) (?Q 1 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?Q 2 ?Y)) (#$implies (#$different ?Y 42) (?P 2 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?P 3 ?Y)) (#$implies (#$equalSymbols ?Y 212) (?Q 3 ?Y))) (#$and (#$isa ?X #$SubLInteger) (?P ?X ?Y) (?Q ?X ?Y))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :MAX-PROBLEM-COUNT 28 :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 0) (?Y . 212)) ((?X . 1) (?Y . 212)) ((?X . 2) (?Y . 212)) ((?X . 3) (?Y . 212)))) :COMMENT "Test that exercises all combinations of potential backchain order to solve.")
  1936. ;;; Result(130)  <==== #<INFERENCE-UNIT-TEST 0>
  1937. ;;; CYC(131): (DEFINE-INFERENCE-UNIT-TEST :BETTER-TACTICIAN-PARTIAL-PROOFS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P1 #$BinaryPredicate) (#$isa ?P2 #$BinaryPredicate) (#$backchainRequired ?P1) (#$backchainRequired ?P2) (#$implies (#$equalSymbols ?ARG1 1) (?P1 ?ARG1 ??ARG2)) (#$implies (#$equalSymbols ?ARG2 2) (?P2 ??ARG1 ?ARG2))) (#$and (?P1 ?ANS1 ?ANS2) (?P2 ?ANS1 ?ANS2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT 1200 :MAX-TRANSFORMATION-DEPTH NIL)) :EXPECTED-RESULT (QUOTE (((?ANS1 . 1) (?ANS2 . 2)))) :COMMENT "Test that requires partial proofs to be answerable.
  1938.    Currently, we only create & bubble up complete proofs.
  1939.    Note : the legacy harness can answer this :-(")
  1940. ;;; Result(131)  <==== #<INFERENCE-UNIT-TEST 0>
  1941. ;;; CYC(132): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-TACTICS-ARE-REMOVAL-IMPOSSIBLE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (#$isa ?Q #$UnaryPredicate) (#$backchainRequired ?Q) (#$implies (#$different 42 ?X) (?Q ?X))) (#$and (?P ?X) (?Q ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 1)) ((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Transformation tactics should all be thrown away wrt removal,
  1942.    and if there are only transformation tactics, the problem should be
  1943.    thrown away wrt removal.")
  1944. ;;; Result(132)  <==== #<INFERENCE-UNIT-TEST 0>
  1945. ;;; CYC(133): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-REMOVAL-PRUNE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (#$isa ?Q #$UnaryPredicate) (#$backchainRequired ?Q) (#$implies (#$different 42 ?X) (?Q ?X))) (#$and (?P ?X) (?Q ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :MAX-TRANSFORMATION-DEPTH 0 :MAX-PROBLEM-COUNT 4)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "A backchainRequired predicate is impossible wrt removal, and
  1946.    therefore should be selected so as to immediately prune.")
  1947. ;;; Result(133)  <==== #<INFERENCE-UNIT-TEST 0>
  1948. ;;; CYC(134): (DEFINE-INFERENCE-UNIT-TEST :VALIDATE-TRANSFORMATION-BINDINGS :OWNER "goolsbey" :WORKING? NIL :BUG 8963 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GENL #$Collection) (#$genls ?GENL #$Individual) (#$isa ?SPEC #$Collection) (#$genls ?SPEC ?GENL) (#$isa ?DISJOINT #$Collection) (#$genls ?DISJOINT ?GENL) (#$disjointWith ?DISJOINT ?SPEC) (#$isa ?GENL-PRED #$UnaryPredicate) (#$isa ?SPEC-PRED #$UnaryPredicate) (#$arg1Isa ?GENL-PRED ?GENL) (#$arg1Isa ?SPEC-PRED ?SPEC) (#$genlPreds ?SPEC-PRED ?GENL-PRED) (#$isa ?OBJ ?DISJOINT) (#$implies (#$unknownSentence (#$equalSymbols 212 ?X)) (?SPEC-PRED ?X))) (?GENL-PRED ?OBJ)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :INTERMEDIATE-STEP-VALIDATION-LEVEL :ALL :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Test whether the intermediate steps of transformation are checked for wff")
  1949. ;;; Result(134)  <==== #<INFERENCE-UNIT-TEST 0>
  1950. ;;; CYC(135): (DEFINE-INFERENCE-UNIT-TEST :RECONSIDER-SET-ASIDE-SIBLING-SPLIT-TACTIC :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?PRED-2 #$UnaryPredicate) (#$backchainRequired ?PRED-1) (#$backchainRequired ?PRED-2) (#$implies (#$equalSymbols ?A 212) (?PRED-1 ?A)) (#$implies (#$equalSymbols ?B 212) (?PRED-2 ?B))) (#$and (#$and (#$greaterThan ?X 42) (?PRED-1 ?X)) (#$and (#$greaterThan ?Y 42) (?PRED-2 ?Y)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?X . 212) (?Y . 212)))) :COMMENT "Consider a split tactic SPLIT which has a sibling split tactic SIBLING
  1951.    that is thrown away wrt removal but not transformation.
  1952.    SPLIT should eventually get R, because SIBLING could be transformed and thereby
  1953.    get proofs (including by removal).  SPLIT may temporarily be set aside
  1954.    wrt removal but it will be reconsidered when SIBLING gets T.
  1955.    @see balanced-strategy-chooses-to-set-aside-split-tactic-wrt-removal?
  1956.    for some code that will affect an intermediate step of this unit test,
  1957.    but will not affect its success.")
  1958. ;;; Result(135)  <==== #<INFERENCE-UNIT-TEST 0>
  1959. ;;; CYC(136): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 2 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 2)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1960.    number of problems, links and proofs due to massive problem and proof reuse.")
  1961. ;;; Result(136)  <==== #<INFERENCE-UNIT-TEST 0>
  1962. ;;; CYC(137): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-3 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 3 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 3)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1963.    number of problems, links and proofs due to massive problem and proof reuse.")
  1964. ;;; Result(137)  <==== #<INFERENCE-UNIT-TEST 0>
  1965. ;;; CYC(138): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-4 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 4 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 5)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1966.    number of problems, links and proofs due to massive problem and proof reuse.")
  1967. ;;; Result(138)  <==== #<INFERENCE-UNIT-TEST 0>
  1968. ;;; CYC(139): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-5 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 5 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 8)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1969.    number of problems, links and proofs due to massive problem and proof reuse.")
  1970. ;;; Result(139)  <==== #<INFERENCE-UNIT-TEST 0>
  1971. ;;; CYC(140): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-6 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 6 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 13)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1972.    number of problems, links and proofs due to massive problem and proof reuse.")
  1973. ;;; Result(140)  <==== #<INFERENCE-UNIT-TEST 0>
  1974. ;;; CYC(141): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-10 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 10 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :PROBABLY-APPROXIMATELY-DONE 1 :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 89)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1975.    number of problems, links and proofs due to massive problem and proof reuse.")
  1976. ;;; Result(141)  <==== #<INFERENCE-UNIT-TEST 0>
  1977. ;;; CYC(142): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-20 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (?FIBONACCI 20 ?ANSWER)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :PROBABLY-APPROXIMATELY-DONE 1 :MAX-NUMBER 1 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?ANSWER . 10946)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1978.    number of problems, links and proofs due to massive problem and proof reuse.")
  1979. ;;; Result(142)  <==== #<INFERENCE-UNIT-TEST 0>
  1980. ;;; CYC(143): (DEFINE-INFERENCE-UNIT-TEST :FIBONACCI-ITERATIVE :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FIBONACCI #$BinaryPredicate) (#$arg1Isa ?FIBONACCI #$Integer) (#$arg2Isa ?FIBONACCI #$Integer) (#$implies (#$and (#$greaterThanOrEqualTo ?N 2) (#$termChosen ?N) (?FIBONACCI (#$DifferenceFn ?N 1) ?FIB-1) (?FIBONACCI (#$DifferenceFn ?N 2) ?FIB-2)) (?FIBONACCI ?N (#$PlusFn ?FIB-1 ?FIB-2))) (?FIBONACCI 0 1) (?FIBONACCI 1 1)) (#$and (#$integerBetween 0 ?N 20) (?FIBONACCI ?N ?ANSWER))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-NUMBER 21 :ALLOW-ABNORMALITY-CHECKING? NIL :INTERMEDIATE-STEP-VALIDATION-LEVEL :NONE)) :EXPECTED-RESULT (QUOTE (((?N . 0) (?ANSWER . 1)) ((?N . 1) (?ANSWER . 1)) ((?N . 2) (?ANSWER . 2)) ((?N . 3) (?ANSWER . 3)) ((?N . 4) (?ANSWER . 5)) ((?N . 5) (?ANSWER . 8)) ((?N . 6) (?ANSWER . 13)) ((?N . 7) (?ANSWER . 21)) ((?N . 8) (?ANSWER . 34)) ((?N . 9) (?ANSWER . 55)) ((?N . 10) (?ANSWER . 89)) ((?N . 11) (?ANSWER . 144)) ((?N . 12) (?ANSWER . 233)) ((?N . 13) (?ANSWER . 377)) ((?N . 14) (?ANSWER . 610)) ((?N . 15) (?ANSWER . 987)) ((?N . 16) (?ANSWER . 1597)) ((?N . 17) (?ANSWER . 2584)) ((?N . 18) (?ANSWER . 4181)) ((?N . 19) (?ANSWER . 6765)) ((?N . 20) (?ANSWER . 10946)))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "Query that has a looping rule with exponential proof fanout but only linear
  1981.    number of problems, links and proofs due to massive problem and proof reuse.")
  1982. ;;; Result(143)  <==== #<INFERENCE-UNIT-TEST 0>
  1983. ;;; CYC(144): (PROGN (DEFINE-PRIVATE PROBLEM-STORE-CONTAINS-A-JOIN-TACTIC-WITH-TRANSFORMATION-MOTIVATION? (STORE STRATEGY) (DO-PROBLEM-STORE-PROBLEMS (PROBLEM STORE) (DO-PROBLEM-TACTICS (JOIN-TACTIC PROBLEM :TYPE :JOIN) (PCOND ((BALANCED-STRATEGY-P STRATEGY) (PWHEN (BALANCED-STRATEGY-LINK-HEAD-MOTIVATED-WRT-TRANSFORMATION? STRATEGY JOIN-TACTIC) (RET T))) ((BALANCING-TACTICIAN-P STRATEGY) (PWHEN (TRANSFORMATION-STRATEGY-LINK-HEAD-MOTIVATED? (BALANCING-TACTICIAN-TRANSFORMATION-SUBSTRATEGY STRATEGY) JOIN-TACTIC) (RET T))) (T (RET (ERROR "unexpected strategy type ~a" STRATEGY)))))) (RET NIL)) (DEFINE-PRIVATE PROBLEM-STORE-CONTAINS-A-JOIN-TACTIC-WITHOUT-TRANSFORMATION-MOTIVATION? (STORE STRATEGY) (DO-PROBLEM-STORE-PROBLEMS (PROBLEM STORE) (DO-PROBLEM-TACTICS (JOIN-TACTIC PROBLEM :TYPE :JOIN) (PCOND ((BALANCED-STRATEGY-P STRATEGY) (PUNLESS (BALANCED-STRATEGY-LINK-HEAD-MOTIVATED-WRT-TRANSFORMATION? STRATEGY JOIN-TACTIC) (RET T))) ((BALANCING-TACTICIAN-P STRATEGY) (PUNLESS (TRANSFORMATION-STRATEGY-LINK-HEAD-MOTIVATED? (BALANCING-TACTICIAN-TRANSFORMATION-SUBSTRATEGY STRATEGY) JOIN-TACTIC) (RET T))) (T (RET (ERROR "unexpected strategy type ~a" STRATEGY)))))) (RET NIL)) (DEFINE-INFERENCE-UNIT-TEST :BALANCED-STRATEGY-DOESNT-GIVE-T-TO-JOIN-LINKS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate)) (#$and (?P ?X) (?Q ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1 :ALLOWED-MODULES (:NOT :JOIN-ORDERED))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE)) (INFERENCE (FIND-INFERENCE-BY-ID STORE 0)) (STRATEGY (SIMPLEST-INFERENCE-STRATEGY INFERENCE))) (CAND (PROBLEM-STORE-CONTAINS-A-JOIN-TACTIC-WITHOUT-TRANSFORMATION-MOTIVATION? STORE STRATEGY) (CNOT (PROBLEM-STORE-CONTAINS-A-JOIN-TACTIC-WITH-TRANSFORMATION-MOTIVATION? STORE STRATEGY))))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "The balanced tactician should never propagate transformation motivation
  1984. to a join link.  Join-ordered links are the only sensible way to propagate transformation motivation
  1985. through a connected conjunction."))
  1986. ;;; Result(144)  <==== #<INFERENCE-UNIT-TEST 0>
  1987. ;;; CYC(145): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-QUERY-UNIQUE-WRT-BINDINGS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?GOOD #$UnaryPredicate) (#$isa ?BAD #$UnaryPredicate) (#$implies (?GOOD ?X) (?PRED ?X)) (#$implies (?BAD ?X) (?PRED ?X)) (#$implies (#$equalSymbols ?X "a") (?GOOD ?X)) (#$implies (#$performSubL (#$SubLQuoteFn (ABORT-CURRENT-CONTROLLING-INFERENCE))) (?BAD ?X)) (#$highlyRelevantAssertion (#$implies (?GOOD ?X) (?PRED ?X))) (#$highlyRelevantAssertion (#$implies (?BAD ?X) (?PRED ?X))) (#$highlyRelevantAssertion (#$implies (#$equalSymbols ?X "a") (?GOOD ?X)))) (#$and (#$trueSubL (#$ExpandSubLFn (?GOOD) (UNASSERT-HIGHLY-RELEVANT-MT-OF-SENTENCE (QUOTE (#$implies (#$equalSymbols ?X "a") (?GOOD ?X)))))) (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :RESULT-UNIQUENESS :BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a closed query will stop as soon as it
  1988.    finds one proof when it's only looking for bindings.")
  1989. ;;; Result(145)  <==== #<INFERENCE-UNIT-TEST 0>
  1990. ;;; CYC(146): (PROGN (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-LINKS-DONT-BREAK-RELEVANT-ASSERTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$isa ?E #$UnaryPredicate) (#$isa ?F #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (#$implies (?C ?X) (?B ?X)) (#$highlyRelevantAssertion (#$implies (?C ?X) (?B ?X))) (#$implies (?D ?X) (?B ?X)) (#$implies (#$and (?CHAFF "yes") (?E "yes")) (?C "yes")) (#$irrelevantAssertion (#$implies (#$and (?CHAFF "yes") (?E "yes")) (?C "yes"))) (#$implies (?F "no") (?D "no")) (#$irrelevantAssertion (#$implies (?F "no") (?D "no"))) (?E "yes") (?CHAFF "yes") (?F "no")) (#$and (#$trueSubL (#$ExpandSubLFn (?E) (UNASSERT-HIGHLY-RELEVANT-MT-OF-SENTENCE (QUOTE (?E "yes"))))) (#$quotedIsa ?WHAT #$SubLString) (?B ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-NUMBER 1 :MAX-TRANSFORMATION-DEPTH 3)) :EXPECTED-RESULT (QUOTE (((?WHAT . "yes")))) :EXPECTED-HALT-REASON :MAX-NUMBER :COMMENT "There was a bug in which residual transformation links were causing a bunch of loops
  1991. in the problem store, which hosed the :relevant-assertion heuristic.  If that heuristic is
  1992. handling loops properly, then it should get down to the point where it has to choose between
  1993. E and F, and it should choose E, because there's a more relevant path leading to E.
  1994. If, on the buggy hand, loops obscure :relevant-assertion, then it will choose F instead because
  1995. it has a smaller literal count."))
  1996. ;;; Result(146)  <==== #<INFERENCE-UNIT-TEST 0>
  1997. ;;; CYC(147): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-TRANSFORMATION-PROOFS-FOR-CLOSED-PROBLEM :OWNER "goolsbey" :BUG 11368 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?Q ?X) (?P "yes")) (?Q "a") (?Q "b")) (?P "yes")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RESULT-UNIQUENESS :PROOF :MAX-TRANSFORMATION-DEPTH 1 :RETURN :SUPPORTS)) :EXPECTED-RESULT 2 :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :COMMENT "Ensure that multiple proofs for closed query transformations are allowed.")
  1998. ;;; Result(147)  <==== #<INFERENCE-UNIT-TEST 0>
  1999. ;;; CYC(148): (DEFINE-INFERENCE-UNIT-TEST :ASSERT-DIRECTION-CHANGE-FOR-BACKWARD-DEDUCED :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$implies (?R ?X) (#$not (?Q ?X))) (#$implies (?Q ?X) (?S ?X)) (#$assertionDirection (#$implies (?Q ?X) (?S ?X)) #$Forward-AssertionDirection) (#$not (?Q "a")) (#$assertionDirection (#$not (?Q "a")) #$Backward-AssertionDirection) (?R "a")) (#$not (?Q ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :CACHE-INFERENCE-RESULTS? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$thereExists ?ASS (#$and (#$assertionSentence ?ASS (?Q "a")) (#$assertionDirection ?ASS #$Backward-AssertionDirection) (#$assertionTruth ?ASS #$False-JustificationTruth) (#$assertionMt ?ASS ?MT) (#$performSubL (#$ExpandSubLFn (?MT) (CYC-ASSERT (QUOTE (?Q "a")) ?MT (QUOTE (:STRENGTH :MONOTONIC :DIRECTION :FORWARD))))))) :PROPERTIES (:BROWSABLE? T) :EXPECTED-RESULT-TEST LENGTH= :EXPECTED-RESULT 1) (:SENTENCE (#$thereExists ?MT (#$ist-Asserted ?MT (?S "a"))) :EXPECTED-RESULT (NIL) :PROPERTIES (:BROWSABLE? T)) (:SENTENCE (#$and (#$ist-Asserted ?MT (?Q "a")) (#$performSubL (#$ExpandSubLFn (?MT) (CYC-ASSERT (QUOTE (#$assertionDirection (?Q "a") #$Backward-AssertionDirection)) ?MT))) (#$performSubL (#$ExpandSubLFn (?MT) (CYC-UNASSERT (QUOTE (?Q "a")) ?MT)))) :EXPECTED-RESULT-TEST LENGTH= :EXPECTED-RESULT 1))) :COMMENT "Verify that changing direction in step 2 was done independently of the truth change.")
  2000. ;;; Result(148)  <==== #<INFERENCE-UNIT-TEST 0>
  2001. ;;; CYC(149): (DEFINE-INFERENCE-UNIT-TEST :INFINITE-RECURSIVE-PROOF-BUBBLING :OWNER "jantos" :BUG 11757 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?F #$UnaryFunction) (#$implies (?Q ?X) (?P (?F ?X))) (#$implies (?P ?X) (?Q (?F ?X))) (?P "a")) (#$and (?P ?X) (#$elementOf "a" (#$TheSet ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH NIL :MAX-STEP 95)) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :EXPECTED-HALT-REASON :MAX-STEP :COMMENT "Ensure that infinite, recursive proof bubbling doesn't cause an error.
  2002.    This is currently handled by rejecting a proof when its max proof bubbling
  2003.    depth exceeds a sanity threshold.")
  2004. ;;; Result(149)  <==== #<INFERENCE-UNIT-TEST 0>
  2005. ;;; CYC(150): (DEFINE-INFERENCE-UNIT-TEST :INFINITE-SELF-RECURSIVE-PROOF-BUBBLING :OWNER "jantos" :BUG 11757 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?SUCC #$UnaryFunction) (#$implies (?P ?X) (?P (?SUCC ?X))) (?P "a")) (#$and (?P ?X) (#$quotedIsa ?X #$SubLString))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2)) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :COMMENT "Ensure that infinite, self-recursive proof bubbling doesn't cause an error.
  2006.    This is currently handled by rejecting a proof when its max proof bubbling
  2007.    depth exceeds a sanity threshold.")
  2008. ;;; Result(150)  <==== #<INFERENCE-UNIT-TEST 0>
  2009. ;;; CYC(151): (DEFINE-INFERENCE-UNIT-TEST :FIND-TRANSFORMATION-PROOF :OWNER "goolsbey" :BUG 11703 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$and (#$equalSymbols ?X 1) (#$integerBetween 1 ??Y 2)) (?P ?X)) (#$exceptWhen (#$equalSymbols ??Y 1) (#$implies (#$and (#$equalSymbols ?X 1) (#$integerBetween 1 ??Y 2)) (?P ?X)))) (?P ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . 1)))) :COMMENT "Ensure that the two transformation proofs for (?P 1) are not
  2010.    merged by find-proof, since they have different subproofs with
  2011.    different direct supports.")
  2012. ;;; Result(151)  <==== #<INFERENCE-UNIT-TEST 0>
  2013. ;;; CYC(152): (DEFINE-INFERENCE-UNIT-TEST :KNOWN-ANTECEDENT-RULE-OPEN-CONTINUABLE :OWNER "pace" :WORKING? NIL :BUG 12716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$knownAntecedentRule (#$implies (?P ?X) (?Q ?X))) (?P "a")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST :COMMENT "The #$knownAntecedentRule meta-assertion should auto-generate a removal
  2014. module for the rule, hence we shouldn't need transformation to solve this.")
  2015. ;;; Result(152)  <==== #<INFERENCE-UNIT-TEST 0>
  2016. ;;; CYC(153): (DEFINE-INFERENCE-UNIT-TEST :KNOWN-ANTECEDENT-RULE-CLOSED-CONTINUABLE :OWNER "pace" :WORKING? NIL :BUG 12716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$knownAntecedentRule (#$implies (?P ?X) (?Q ?X))) (?P "a")) (?Q "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "The #$knownAntecedentRule meta-assertion should auto-generate a removal
  2017. module for the rule, hence we shouldn't need transformation to solve this.")
  2018. ;;; Result(153)  <==== #<INFERENCE-UNIT-TEST 0>
  2019. ;;; CYC(154): (DEFINE-INFERENCE-UNIT-TEST :KNOWN-ANTECEDENT-RULE-OPEN-NON-CONTINUABLE :OWNER "pace" :WORKING? NIL :BUG 12716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$knownAntecedentRule (#$implies (?P ?X) (?Q ?X))) (?P "a")) (?Q ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? NIL)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "The #$knownAntecedentRule meta-assertion should auto-generate a removal
  2020. module for the rule, hence we shouldn't need transformation to solve this.")
  2021. ;;; Result(154)  <==== #<INFERENCE-UNIT-TEST 0>
  2022. ;;; CYC(155): (DEFINE-INFERENCE-UNIT-TEST :KNOWN-ANTECEDENT-RULE-CLOSED-NON-CONTINUABLE :OWNER "pace" :WORKING? NIL :BUG 12716 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$knownAntecedentRule (#$implies (?P ?X) (?Q ?X))) (?P "a")) (?Q "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? NIL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "The #$knownAntecedentRule meta-assertion should auto-generate a removal
  2023. module for the rule, hence we shouldn't need transformation to solve this.")
  2024. ;;; Result(155)  <==== #<INFERENCE-UNIT-TEST 0>
  2025. ;;; CYC(156): (DEFINE-INFERENCE-UNIT-TEST :IMPOSSIBLE-UNBOUND-PREDICATE-REMOVAL-AFTER-TRANSFORMATION :OWNER "goolsbey" :BUG 15771 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?ANTE #$UnaryPredicate) (#$isa ?CONSEQ #$UnaryPredicate) (#$isa ?PRED #$UnaryPredicate) (#$isa ?TERM-A #$Individual) (#$isa ?TERM-B #$Individual) (#$different ?TERM-A ?TERM-B) (?PRED ?ANTE) (?ANTE ?TERM-B) (#$implies (#$and (?P ?Q) (?PRED ?P) (#$different ?Q ?TERM-A)) (?CONSEQ ?Q))) (?CONSEQ ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 100 :MAX-TRANSFORMATION-DEPTH 1 :PROBABLY-APPROXIMATELY-DONE 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-B)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?ANTE-1 #$UnaryPredicate) (#$isa ?CONSEQ-1 #$UnaryPredicate) (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?TERM-A-1 #$Individual) (#$isa ?TERM-B-1 #$Individual) (#$different ?TERM-A-1 ?TERM-B-1) (?PRED-1 ?ANTE-1) (?ANTE-1 ?TERM-B-1) (#$implies (#$and (?P ?Q) (?PRED-1 ?P) (#$different ?Q ?TERM-A-1)) (?CONSEQ-1 ?Q))) (?CONSEQ-1 ?WHAT))) :PROPERTIES (:PROBLEM-STORE NIL :CONDITIONAL-SENTENCE? T :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 100 :MAX-TRANSFORMATION-DEPTH 2 :PROBABLY-APPROXIMATELY-DONE 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS) :EXPECTED-RESULT (((?WHAT . ?TERM-B-1))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "After transformation, the (?P ?Q) literal should be considered impossible
  2026.    wrt removal and therefore not selected when choosing join-ordered links
  2027.    for R propagation.")
  2028. ;;; Result(156)  <==== #<INFERENCE-UNIT-TEST 0>
  2029. ;;; CYC(157): (DEFINE-INFERENCE-UNIT-TEST :IMPOSSIBLE-UNBOUND-PREDICATE-REMOVAL :OWNER "goolsbey" :BUG 15771 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?ANTE #$UnaryPredicate) (#$isa ?CONSEQ #$UnaryPredicate) (#$isa ?PRED #$UnaryPredicate) (#$isa ?TERM-A #$Individual) (#$isa ?TERM-B #$Individual) (#$different ?TERM-A ?TERM-B) (?PRED ?ANTE) (?ANTE ?TERM-B)) (#$thereExists ?P (#$and (?P ?WHAT) (?PRED ?P) (#$different ?WHAT ?TERM-A)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 100 :MAX-TRANSFORMATION-DEPTH 0 :PROBABLY-APPROXIMATELY-DONE 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?WHAT . ?TERM-B)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?ANTE-1 #$UnaryPredicate) (#$isa ?CONSEQ-1 #$UnaryPredicate) (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?TERM-A-1 #$Individual) (#$isa ?TERM-B-1 #$Individual) (#$different ?TERM-A-1 ?TERM-B-1) (?PRED-1 ?ANTE-1) (?ANTE-1 ?TERM-B-1)) (#$thereExists ?P (#$and (?P ?WHAT) (?PRED-1 ?P) (#$different ?WHAT ?TERM-A-1))))) :PROPERTIES (:PROBLEM-STORE NIL :CONDITIONAL-SENTENCE? T :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 100 :MAX-TRANSFORMATION-DEPTH 1 :PROBABLY-APPROXIMATELY-DONE 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS) :EXPECTED-RESULT (((?WHAT . ?TERM-B-1))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Like :impossible-unbound-predicate-removal-after-transformation except asks
  2030. the transformed antecedent of the rule, and hence does not need a transformation to succeed")
  2031. ;;; Result(157)  <==== #<INFERENCE-UNIT-TEST 0>
  2032. ;;; CYC(158): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-TO-REMOVAL-TRUE-SENTENCE-UNIVERSAL-DISJUNCTION-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$sentenceTruth (#$forAll ?X (#$implies (#$isa ?X #$Predicate) (#$isa ?X #$Individual))) ?TRUTH))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1)) :KB :TINY :EXPECTED-RESULT (QUOTE (((?TRUTH . #$True)))) :COMMENT "test that we can backchain on #$sentenceTruth
  2033. and then use the :removal-true-sentence-universal-disjunction module
  2034. to prove the resultant query.")
  2035. ;;; Result(158)  <==== #<INFERENCE-UNIT-TEST 0>
  2036. ;;; CYC(159): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-TO-REMOVAL-TRUE-SENTENCE-UNIVERSAL-DISJUNCTION-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$sentenceTruth (#$not (#$thereExists ?X (#$and (#$isa ?X #$Collection) (#$isa ?X #$Individual)))) ?TRUTH))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1)) :KB :TINY :EXPECTED-RESULT (QUOTE (((?TRUTH . #$True)))) :COMMENT "test that we can backchain on #$sentenceTruth
  2037. and then use the :removal-true-sentence-universal-disjunction module
  2038. to prove the resultant query.")
  2039. ;;; Result(159)  <==== #<INFERENCE-UNIT-TEST 0>
  2040. ;;; CYC(160): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-TO-REMOVAL-TRUE-SENTENCE-UNIVERSAL-DISJUNCTION-3 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$sentenceTruth (#$thereExists ?X (#$and (#$isa ?X #$Collection) (#$isa ?X #$Individual))) ?TRUTH))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1)) :KB :TINY :EXPECTED-RESULT (QUOTE (((?TRUTH . #$False)))) :COMMENT "test that we can backchain on #$sentenceTruth
  2041. and then use the :removal-true-sentence-universal-disjunction module
  2042. to prove the negation of the resultant query.  This relies on
  2043. the inference czer converting #$not #$trueSentence -> #$trueSentence #$not")
  2044. ;;; Result(160)  <==== #<INFERENCE-UNIT-TEST 0>
  2045. ;;; CYC(161): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-PRUNING-MODULE :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-1 #$UnaryPredicate) (#$isa ?PRED-2 #$UnaryPredicate) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?OBJ-1 #$Individual) (#$backchainRequired ?PRED-1) (#$implies (?PRED-2 ?X) (?PRED-1 ?X)) (?PRED-2 (?FUNC ?OBJ-1))) (?PRED-1 (?FUNC ?X))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :ALLOWED-MODULES (:NOT :JOIN) :CONDITIONAL-SENTENCE? T :BROWSABLE? T :PROBABLY-APPROXIMATELY-DONE 1 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?OBJ-1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$evaluate ?COUNT (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (PROBLEM-EXECUTED-TACTICS (FIND-PREVIOUS-INFERENCE-PROBLEM-BY-EL-ASENT (QUOTE (#$termOfUnit ?VAR0 (?FUNC ?VAR1)))))))))) :EXPECTED-RESULT (((?COUNT . 0))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "Test that the pruning module for backchainRequired predicates works.
  2046.    I.e., that the pruning module prevents work on the not-fully-bound
  2047.    termOfUnit literal in the HL query.")
  2048. ;;; Result(161)  <==== #<INFERENCE-UNIT-TEST 0>
  2049. ;;; CYC(162): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-PRUNING-MODULE-DELAY :OWNER "kknight" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-1 #$BinaryPredicate) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?COL #$Collection) (#$isa ?OBJ-1 ?COL) (#$isa ?OBJ-2 #$Individual) (#$backchainForbiddenWhenUnboundInArg ?PRED-1 1) (#$backchainRequired ?PRED-1) (#$implies (?PRED-2 ?X ?Y) (?PRED-1 ?X ?Y)) (?PRED-2 ?OBJ-1 ?OBJ-2)) (#$and (#$isa ?X ?COL) (?PRED-1 ?X ?Y))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T :PROBABLY-APPROXIMATELY-DONE 1 :REMOVAL-BACKTRACKING-PRODUCTIVITY-LIMIT 0 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . ?OBJ-1) (?Y . ?OBJ-2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :KB :TINY :COMMENT "Test that the pruning module for backchainRequired predicates works
  2050.    as a delay module if the predicate is also #$backchainForbiddenWhenUnboundInArg.")
  2051. ;;; Result(162)  <==== #<INFERENCE-UNIT-TEST 0>
  2052. ;;; CYC(163): (PROGN (DEFINE INFERENCE-UNIT-TEST-NONNEGATIVE-INTEGER? (INT) (PUNLESS (INTEGERP INT) (RET NIL)) (RET (>= INT 0))) (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-RESIDUAL-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?IND #$Individual) (#$isa ?COL #$Collection) (#$defnSufficient ?COL (#$SubLQuoteFn INFERENCE-UNIT-TEST-NONNEGATIVE-INTEGER?)) (#$isa ?FN-A #$BinaryFunction) (#$arg1Isa ?FN-A ?COL) (#$resultIsa ?FN-A #$Individual) (#$isa ?FN-B #$BinaryFunction) (#$arg1Isa ?FN-B ?COL) (#$resultIsa ?FN-B #$Individual) (#$forAll ?HR (#$forAll ??N (?PRED ?HR (?FN-A ??N ?HR)))) (#$forAll ?DAY (#$forAll ??N (?PRED ?DAY (?FN-B ??N ?DAY))))) (#$and (?PRED ?IND ?X) (?PRED ?X (?FN-A 35 (?FN-B 20 ?IND))))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 2 :CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X ?FN-B 20 ?IND)))) :KB :TINY :COMMENT "Like transform-unify except skips the application of the transitivity rule."))
  2053. ;;; Result(163)  <==== #<INFERENCE-UNIT-TEST 0>
  2054. ;;; CYC(164): (PROGN (DEFINE-PRIVATE MAX-TRANSFORMATION-DEPTH-INTUITIVE-OR-NOT-HELPER (STORE PRED-C PRED-D) (CLET ((INFERENCE (FIND-INFERENCE-BY-ID STORE 0)) (PROBLEM-C (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-CONS PRED-C (QUOTE (?X))) #$InferencePSC)) (PROBLEM-D (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-CONS PRED-D (QUOTE (?X))) #$InferencePSC)) (PROBLEM-CD (FIND-PROBLEM-BY-EL-QUERY STORE (BQ-LIST #$and (BQ-CONS PRED-C (QUOTE (?X))) (BQ-CONS PRED-D (QUOTE (?X)))) #$InferencePSC))) (PWHEN (CAND INFERENCE PROBLEM-C PROBLEM-D) (PWHEN PROBLEM-CD (CLET ((B-DEPTH (PROBLEM-MIN-TRANSFORMATION-DEPTH PROBLEM-C INFERENCE)) (D-DEPTH (PROBLEM-MIN-TRANSFORMATION-DEPTH PROBLEM-D INFERENCE)) (BD-DEPTH (PROBLEM-MIN-TRANSFORMATION-DEPTH PROBLEM-CD INFERENCE))) (PWHEN (CAND (= 1 B-DEPTH) (= 1 D-DEPTH)) (PIF (EQ :INTUITIVE *TRANSFORMATION-DEPTH-COMPUTATION*) (PWHEN (= 2 BD-DEPTH) (RET T)) (PWHEN (= 1 BD-DEPTH) (RET T))))))))) (DEFINE-INFERENCE-UNIT-TEST :MAX-TRANSFORMATION-DEPTH-INTUITIVE-OR-NOT :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?A #$UnaryPredicate) (#$isa ?B #$UnaryPredicate) (#$isa ?C #$UnaryPredicate) (#$isa ?D #$UnaryPredicate) (#$implies (?C ?X) (?A ?X)) (#$implies (?D ?X) (?B ?X))) (#$ist #$InferencePSC (#$and (?A ?X) (?B ?X)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 2 :CONDITIONAL-SENTENCE? T :BROWSABLE? T)) :EXPECTED-RESULT NIL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (MAX-TRANSFORMATION-DEPTH-INTUITIVE-OR-NOT-HELPER (CURRENTLY-ACTIVE-PROBLEM-STORE) ?C ?D)))) :PROPERTIES (:CONTINUABLE? NIL) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :KB :TINY :COMMENT "Test that (^ C D) has the right transformation depth,
  2055. which is 2 if *transformation-depth-computation* is :intuitive
  2056. and 1 if *transformation-depth-computation* is :counterintuitive."))
  2057. ;;; Result(164)  <==== #<INFERENCE-UNIT-TEST 0>
  2058. ;;; CYC(165): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-UNIFY-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$forAll ?HR (#$forAll ??N (?PRED ?HR (?FN-A ??N ?HR))))) (?PRED ?X (?FN-A 35 "a"))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :KB :TINY :COMMENT "Test that single-literal transformation unification bindings-foo works.")
  2059. ;;; Result(165)  <==== #<INFERENCE-UNIT-TEST 0>
  2060. ;;; CYC(166): (DEFINE-INFERENCE-UNIT-TEST :SINGLE-LITERAL-RULE-UNIFY-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$UnaryFunction) (#$forAll ?HR (#$forAll ??N (?PRED ?HR (?FN-A ??N ?HR))))) (?PRED (?FN-B ?X) (?FN-A 35 (?FN-B "a")))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?X . "a")))) :KB :TINY :COMMENT "Test that single-literal transformation unification bindings-foo works.")
  2061. ;;; Result(166)  <==== #<INFERENCE-UNIT-TEST 0>
  2062. ;;; CYC(167): (DEFINE-INFERENCE-UNIT-TEST :CHAINING-FAUX-SKOLEM :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?ISA #$BinaryPredicate) (#$isa ?HAS-PARTS #$BinaryPredicate) (#$isa ?KLINGON #$Collection) (#$isa ?ARM #$Collection) (#$isa ?HAND #$Collection) (#$isa ?LEERSA ?KLINGON) (?ISA ?LEERSA ?KLINGON) (#$isa ?ARM-FN #$UnaryFunction) (#$isa ?ARM-FN #$ReifiableFunction) (#$isa ?HAND-FN #$BinaryFunction) (#$isa ?HAND-FN #$ReifiableFunction) (#$implies (#$isa ?PERSON ?KLINGON) (#$and (?HAS-PARTS ?PERSON (?ARM-FN ?PERSON)) (?ISA (?ARM-FN ?PERSON) ?ARM))) (#$implies (#$and (?ISA ?A ?ARM) (?HAS-PARTS ?PERSON ?A)) (#$and (?HAS-PARTS ?PERSON (?HAND-FN ?A ?PERSON)) (?ISA (?HAND-FN ?A ?PERSON) ?HAND)))) (#$thereExists ?WHAT (#$and (?HAS-PARTS ?LEERSA ?WHAT) (?ISA ?WHAT ?HAND)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 2 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "A unit test distilled from the :chaining-skolem inference test,
  2063. but makes its own arm and hand-denoting functions instead of using actual skolems.
  2064. @note this was intentionally not working for a while due to *better-residual-transformation?*.")
  2065. ;;; Result(167)  <==== #<INFERENCE-UNIT-TEST 0>
  2066. ;;; CYC(168): (DEFINE-INFERENCE-UNIT-TEST :CHAINING-FAUX-SKOLEM-UNBOUNDED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?ISA #$BinaryPredicate) (#$isa ?HAS-PARTS #$BinaryPredicate) (#$isa ?KLINGON #$Collection) (#$isa ?ARM #$Collection) (#$isa ?HAND #$Collection) (#$isa ?LEERSA ?KLINGON) (?ISA ?LEERSA ?KLINGON) (#$isa ?ARM-FN #$UnaryFunction) (#$isa ?ARM-FN #$ReifiableFunction) (#$isa ?HAND-FN #$BinaryFunction) (#$isa ?HAND-FN #$ReifiableFunction) (#$implies (#$isa ?PERSON ?KLINGON) (#$and (?HAS-PARTS ?PERSON (?ARM-FN ?PERSON)) (?ISA (?ARM-FN ?PERSON) ?ARM))) (#$implies (#$and (?ISA ?A ?ARM) (?HAS-PARTS ?PERSON ?A)) (#$and (?HAS-PARTS ?PERSON (?HAND-FN ?A ?PERSON)) (?ISA (?HAND-FN ?A ?PERSON) ?HAND)))) (#$thereExists ?WHAT (#$and (?HAS-PARTS ?LEERSA ?WHAT) (?ISA ?WHAT ?HAND)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH NIL :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Like :chaining-faux-skolem except with unbounded transformation depth.")
  2067. ;;; Result(168)  <==== #<INFERENCE-UNIT-TEST 0>
  2068. ;;; CYC(169): (DEFINE-INFERENCE-UNIT-TEST :CHAINING-FAUX-SKOLEM-2 :OWNER "pace" :BUG 20959 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?ISA #$BinaryPredicate) (#$isa ?HAS-ARM #$BinaryPredicate) (#$isa ?HAS-HAND #$BinaryPredicate) (#$isa ?KLINGON #$Collection) (#$isa ?ARM #$Collection) (#$isa ?HAND #$Collection) (#$isa ?LEERSA ?KLINGON) (?ISA ?LEERSA ?KLINGON) (#$isa ?ARM-FN #$UnaryFunction) (#$isa ?ARM-FN #$ReifiableFunction) (#$isa ?HAND-FN #$BinaryFunction) (#$isa ?HAND-FN #$ReifiableFunction) (#$implies (#$isa ?PERSON ?KLINGON) (#$and (?HAS-ARM ?PERSON (?ARM-FN ?PERSON)) (?ISA (?ARM-FN ?PERSON) ?ARM))) (#$implies (#$and (?ISA ?A ?ARM) (?HAS-ARM ?PERSON ?A)) (#$and (?HAS-HAND ?PERSON (?HAND-FN ?A ?PERSON)) (?ISA (?HAND-FN ?A ?PERSON) ?HAND)))) (#$thereExists ?WHAT (#$and (?HAS-HAND ?LEERSA ?WHAT) (?ISA ?WHAT ?HAND)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 2 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Like :chaining-faux-skolem except doesn't use any self-looping rules.
  2069.   This used to work with a :max-transformation-depth of 2 until bug
  2070.   20959 was fixed.  Now it requires 4.  It might be fixable if we
  2071.   had a rewrite module to merge nats, like removal-nat-reduction in
  2072.   the old harness.")
  2073. ;;; Result(169)  <==== #<INFERENCE-UNIT-TEST 0>
  2074. ;;; CYC(170): (DEFINE-INFERENCE-UNIT-TEST :CHAINING-FAUX-SKOLEM-2-DEEP :OWNER "pace" :BUG 20959 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?ISA #$BinaryPredicate) (#$isa ?HAS-ARM #$BinaryPredicate) (#$isa ?HAS-HAND #$BinaryPredicate) (#$isa ?KLINGON #$Collection) (#$isa ?ARM #$Collection) (#$isa ?HAND #$Collection) (#$isa ?LEERSA ?KLINGON) (?ISA ?LEERSA ?KLINGON) (#$isa ?ARM-FN #$UnaryFunction) (#$isa ?ARM-FN #$ReifiableFunction) (#$isa ?HAND-FN #$BinaryFunction) (#$isa ?HAND-FN #$ReifiableFunction) (#$and (#$constantName ?ISA "pred-Isa") (#$constantName ?HAS-ARM "hasArm") (#$constantName ?HAS-HAND "hasHand") (#$constantName ?KLINGON "Klingon") (#$constantName ?ARM "Arm") (#$constantName ?HAND "Hand") (#$constantName ?LEERSA "Leersa") (#$constantName ?ARM-FN "ArmFn") (#$constantName ?HAND-FN "HandFn")) (#$implies (#$isa ?PERSON ?KLINGON) (#$and (?HAS-ARM ?PERSON (?ARM-FN ?PERSON)) (?ISA (?ARM-FN ?PERSON) ?ARM))) (#$implies (#$and (?ISA ?A ?ARM) (?HAS-ARM ?PERSON ?A)) (#$and (?HAS-HAND ?PERSON (?HAND-FN ?A ?PERSON)) (?ISA (?HAND-FN ?A ?PERSON) ?HAND)))) (#$thereExists ?WHAT (#$and (?HAS-HAND ?LEERSA ?WHAT) (?ISA ?WHAT ?HAND)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 4 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Like :chaining-faux-skolem-2 except has a max transformation depth
  2075.   of 4 instead of 2.  However, this too is failing due to the lack of
  2076.   removal-nat-reduction.")
  2077. ;;; Result(170)  <==== #<INFERENCE-UNIT-TEST 0>
  2078. ;;; CYC(171): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-RECONSIDERATION-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P ?X))) (#$and (#$different 1 2) (?P ?Y))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?Y . 212)))) :KB :TINY :COMMENT "Baseline for split-reconsideration-2")
  2079. ;;; Result(171)  <==== #<INFERENCE-UNIT-TEST 0>
  2080. ;;; CYC(172): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-RECONSIDERATION-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$implies (#$equalSymbols ?X 212) (?P ?X))) (#$and (#$different 1 2) (?P ?Y))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T :ALLOWED-MODULES (:NOT :REMOVAL-LOOKUP-POS))) :EXPECTED-RESULT (QUOTE (((?Y . 212)))) :KB :TINY :COMMENT "Test split reconsideration when no removal tactics are required on the other literal,
  2081. which effectively makes it backchainRequired")
  2082. ;;; Result(172)  <==== #<INFERENCE-UNIT-TEST 0>
  2083. ;;; CYC(173): (DEFINE-INFERENCE-UNIT-TEST :SPLIT-RECONSIDERATION-3 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$backchainRequired ?P) (#$implies (#$equalSymbols ?X 212) (?P ?X))) (#$and (#$different 1 2) (?P ?Y))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?Y . 212)))) :KB :TINY :COMMENT "Test split reconsideration with a backchainRequired predicate.")
  2084. ;;; Result(173)  <==== #<INFERENCE-UNIT-TEST 0>
  2085. ;;; CYC(174): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-ISA-BACKCHAIN-REQUIRED-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?INS ?COL) (#$collectionIsaBackchainRequired ?COL)) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that #$collectionIsaBackchainRequired inhibits removal on #$isa")
  2086. ;;; Result(174)  <==== #<INFERENCE-UNIT-TEST 0>
  2087. ;;; CYC(175): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-ISA-BACKCHAIN-REQUIRED-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$genls ?SPEC ?COL) (#$collectionIsaBackchainRequired ?COL)) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionIsaBackchainRequired does not inhibit removal on #$genls")
  2088. ;;; Result(175)  <==== #<INFERENCE-UNIT-TEST 0>
  2089. ;;; CYC(176): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-ISA-BACKCHAIN-REQUIRED-3 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$implies (#$equalSymbols ?INS 212) (#$isa ?INS ?COL))) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that the inference engine doesn't backchain on #$isa without #$collectionIsaBackchainRequired")
  2090. ;;; Result(176)  <==== #<INFERENCE-UNIT-TEST 0>
  2091. ;;; CYC(177): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-ISA-BACKCHAIN-REQUIRED-4 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$implies (#$equalSymbols ?INS 212) (#$isa ?INS ?COL)) (#$collectionIsaBackchainRequired ?COL)) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionIsaBackchainRequired encourages transformation on #$isa")
  2092. ;;; Result(177)  <==== #<INFERENCE-UNIT-TEST 0>
  2093. ;;; CYC(178): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-GENLS-BACKCHAIN-REQUIRED-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$genls ?SPEC ?COL) (#$collectionGenlsBackchainRequired ?COL)) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that #$collectionGenlsBackchainRequired inhibits removal on #$genls")
  2094. ;;; Result(178)  <==== #<INFERENCE-UNIT-TEST 0>
  2095. ;;; CYC(179): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-GENLS-BACKCHAIN-REQUIRED-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?INS ?COL) (#$collectionGenlsBackchainRequired ?COL)) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionGenlsBackchainRequired does not inhibit removal on #$isa")
  2096. ;;; Result(179)  <==== #<INFERENCE-UNIT-TEST 0>
  2097. ;;; CYC(180): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-GENLS-BACKCHAIN-REQUIRED-3 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$implies (#$equalSymbols ?OTHER-COL ?SPEC) (#$genls ?OTHER-COL ?COL))) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that the inference engine doesn't backchain on #$genls without #$collectionGenlsBackchainRequired")
  2098. ;;; Result(180)  <==== #<INFERENCE-UNIT-TEST 0>
  2099. ;;; CYC(181): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-GENLS-BACKCHAIN-REQUIRED-4 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$implies (#$equalSymbols ?OTHER-COL ?SPEC) (#$genls ?OTHER-COL ?COL)) (#$collectionGenlsBackchainRequired ?COL)) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionGenlsBackchainRequired encourages transformation on #$genls")
  2100. ;;; Result(181)  <==== #<INFERENCE-UNIT-TEST 0>
  2101. ;;; CYC(182): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-REQUIRED-1 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?INS ?COL) (#$collectionBackchainRequired ?COL)) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that #$collectionBackchainRequired inhibits removal on #$isa")
  2102. ;;; Result(182)  <==== #<INFERENCE-UNIT-TEST 0>
  2103. ;;; CYC(183): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-REQUIRED-2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$genls ?COL ?SPEC) (#$collectionBackchainRequired ?COL)) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :KB :TINY :COMMENT "Test that #$collectionBackchainRequired inhibits removal on #$genls")
  2104. ;;; Result(183)  <==== #<INFERENCE-UNIT-TEST 0>
  2105. ;;; CYC(184): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-REQUIRED-3 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$implies (#$equalSymbols ?INS 212) (#$isa ?INS ?COL)) (#$collectionBackchainRequired ?COL)) (#$thereExists ?X (#$isa ?X ?COL))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionBackchainRequired encourages transformation on #$isa")
  2106. ;;; Result(184)  <==== #<INFERENCE-UNIT-TEST 0>
  2107. ;;; CYC(185): (DEFINE-INFERENCE-UNIT-TEST :COLLECTION-BACKCHAIN-REQUIRED-4 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?SPEC #$Collection) (#$different ?COL ?SPEC) (#$implies (#$equalSymbols ?OTHER-COL ?SPEC) (#$genls ?OTHER-COL ?COL)) (#$collectionBackchainRequired ?COL)) (#$thereExists ?X (#$and (#$genls ?X ?COL) (#$different ?X ?COL)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :TINY :COMMENT "Test that #$collectionBackchainRequired encourages transformation on #$genls")
  2108. ;;; Result(185)  <==== #<INFERENCE-UNIT-TEST 0>
  2109. ;;; CYC(186): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-NON-WFF :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?MAM #$Collection) (#$isa ?DOG #$Collection) (#$isa ?CAT #$Collection) (#$ist #$BaseKB (#$genls ?MAM #$Individual)) (#$ist #$BaseKB (#$genls ?DOG ?MAM)) (#$ist #$BaseKB (#$genls ?CAT ?MAM)) (#$ist #$BaseKB (#$disjointWith ?DOG ?CAT)) (#$isa ?P #$BinaryPredicate) (#$arg1Isa ?P ?MAM) (#$implies (#$isa ?X ?DOG) (?P ?X 1)) (#$implies (#$and (#$isa ?X ?CAT) (#$evaluate ?X (#$EvaluateSubLFn (#$SubLQuoteFn (ABORT-CURRENT-CONTROLLING-INFERENCE))))) (?P ?X 2)) (#$isa ?TERM ?DOG)) (#$thereExists ?WHAT (#$and (#$isa ?WHAT ?DOG) (?P ?WHAT ?NUM)))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 1 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUM . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a non-wff residual of a rule application is pruned eagerly.")
  2110. ;;; Result(186)  <==== #<INFERENCE-UNIT-TEST 0>
  2111. ;;; CYC(187): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-FUNCTIONAL-SIMPLIFICATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$FunctionalPredicate) (#$isa ?P #$BinaryPredicate) (#$strictlyFunctionalInArgs ?P 1) (#$strictlyFunctionalInArgs ?P 2) (?P "a" "b")) (#$thereExists ?X (#$and (?P ?X "b") (?P ?X ?Y)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?Y . "b")))) :KB :FULL :COMMENT "Test that removal motivation is properly flowing after functional simplification.")
  2112. ;;; Result(187)  <==== #<INFERENCE-UNIT-TEST 0>
  2113. ;;; CYC(188): (DEFINE-INFERENCE-UNIT-TEST :FUNCTIONAL-SIMPLIFICATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC-PRED #$FunctionalPredicate) (#$isa ?FUNC-PRED #$BinaryPredicate) (#$functionalInArgs ?FUNC-PRED 2) (#$isa ?PRED #$BinaryPredicate) (#$backchainRequired ?PRED) (#$implies (#$quotedIsa ?N #$SubLInteger) (?FUNC-PRED "a" ?N)) (#$implies (?FUNC-PRED ?X ?Y) (?PRED ?X ?Y))) (#$and (?PRED ?STRING ?NUM) (?PRED ?STRING 212))))) :PROPERTIES (QUOTE (:MAX-TRANSFORMATION-DEPTH 2 :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?STRING . "a") (?NUM . 212)))) :KB :FULL :COMMENT "Test that function simplification is occurring in the problem store.")
  2114. ;;; Result(188)  <==== #<INFERENCE-UNIT-TEST 0>
  2115. ;;; CYC(189): (DEFINE-INFERENCE-UNIT-TEST :FUNCTIONAL-SIMPLIFICATION-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$CurrentWorldDataCollectorMt-NonHomocentric (#$and (#$capitalCityOfState ?STATE ?OTH-CITY) (#$capitalCityOfState ?STATE #$CityOfAustinTX) (#$capitalCityOfState ?STATE ?CITY) (#$capitalCityOfState #$Texas-State ?CITY) (#$capitalCityOfState ?OTH-STATE ?CITY)))) :PROPERTIES (QUOTE (:ALLOWED-MODULES (:NOT (:OR :JOIN-ORDERED :JOIN :SPLIT)))) :EXPECTED-RESULT (QUOTE (((?CITY . #$CityOfAustinTX) (?STATE . #$Texas-State) (?OTH-CITY . #$CityOfAustinTX) (?OTH-STATE . #$Texas-State)))) :KB :FULL :COMMENT "A full KB example of root simpflication.")
  2116. ;;; Result(189)  <==== #<INFERENCE-UNIT-TEST 0>
  2117. ;;; CYC(190): (DEFINE-INFERENCE-UNIT-TEST :FUNCTIONAL-SIMPLIFICATION-3 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$CurrentWorldDataCollectorMt-NonHomocentric (#$and (#$capitalCityOfState #$Texas-State ?CITY) (#$cityInState ?CITY ?STATE) (#$cityInState ?CITY ?OTH-STATE)))) :PROPERTIES (QUOTE (:ALLOWED-MODULES (:NOT :SPLIT) :ALLOW-INDETERMINATE-RESULTS? NIL)) :EXPECTED-RESULT (QUOTE (((?CITY . #$CityOfAustinTX) (?STATE . #$Texas-State) (?OTH-STATE . #$Texas-State)))) :KB :FULL :COMMENT "A full KB example of root simpflication.")
  2118. ;;; Result(190)  <==== #<INFERENCE-UNIT-TEST 0>
  2119. ;;; CYC(191): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-FACTORIAL-REDUCTION :OWNER "goolsbey" :KB :TINY :BUG 22339 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?Q-0 #$UnaryPredicate) (#$isa ?Q-1 #$UnaryPredicate) (#$and (#$isa ?Q-2 #$UnaryPredicate) (#$isa ?Q-3 #$UnaryPredicate) (#$isa ?Q-4 #$UnaryPredicate) (#$isa ?Q-5 #$UnaryPredicate) (#$isa ?Q-6 #$UnaryPredicate) (#$isa ?Q-7 #$UnaryPredicate) (#$isa ?Q-8 #$UnaryPredicate) (#$isa ?Q-9 #$UnaryPredicate)) (#$backchainRequired ?Q-0) (#$backchainRequired ?Q-1) (#$and (#$backchainRequired ?Q-2) (#$backchainRequired ?Q-3) (#$backchainRequired ?Q-4) (#$backchainRequired ?Q-5) (#$backchainRequired ?Q-6) (#$backchainRequired ?Q-7) (#$backchainRequired ?Q-8) (#$backchainRequired ?Q-9)) (#$isa ?P-0 #$UnaryPredicate) (#$isa ?P-1 #$UnaryPredicate) (#$and (#$isa ?P-2 #$UnaryPredicate) (#$isa ?P-3 #$UnaryPredicate) (#$isa ?P-4 #$UnaryPredicate) (#$isa ?P-5 #$UnaryPredicate) (#$isa ?P-6 #$UnaryPredicate) (#$isa ?P-7 #$UnaryPredicate) (#$isa ?P-8 #$UnaryPredicate) (#$isa ?P-9 #$UnaryPredicate)) (#$implies (?P-0 ?X) (?Q-0 ?X)) (#$implies (?P-1 ?X) (?Q-1 ?X)) (#$and (#$implies (?P-2 ?X) (?Q-2 ?X)) (#$implies (?P-3 ?X) (?Q-3 ?X)) (#$implies (?P-4 ?X) (?Q-4 ?X)) (#$implies (?P-5 ?X) (?Q-5 ?X)) (#$implies (?P-6 ?X) (?Q-6 ?X)) (#$implies (?P-7 ?X) (?Q-7 ?X)) (#$implies (?P-8 ?X) (?Q-8 ?X)) (#$implies (?P-9 ?X) (?Q-9 ?X))) (?P-0 0) (?P-1 0) (?P-2 0) (?P-3 0) (#$and (?P-4 0) (?P-5 0) (?P-6 0) (?P-7 0) (?P-8 0) (?P-9 0))) (#$and (?Q-0 ?NUM) (?Q-1 ?NUM) (?Q-2 ?NUM) (?Q-3 ?NUM) (?Q-4 ?NUM) (?Q-5 ?NUM) (?Q-6 ?NUM) (?Q-7 ?NUM) (?Q-8 ?NUM) (?Q-9 ?NUM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :MAX-PROBLEM-COUNT 89 :METRICS (:PROBLEM-COUNT))) :EXPECTED-RESULT (QUOTE (((?NUM . 0)))) :COMMENT "This should take O(N) time and space rather than O(N!) time.")
  2120. ;;; Result(191)  <==== #<INFERENCE-UNIT-TEST 0>
  2121. ;;; CYC(192): (DEFINE-INFERENCE-UNIT-TEST :MAX-TRANSFORMATION-DEPTH-WITH-REUSE :OWNER "goolsbey" :KB :TINY :BUG 22380 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$implies (#$integerBetween 1 ?X 2) (?PRED ?X))) (#$and (?PRED ?LOW) (?PRED ?HIGH) (#$greaterThan ?HIGH ?LOW))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?HIGH . 2) (?LOW . 1)))) :COMMENT "Even though the same rule is used twice, :max-transformation-depth 1 should suffice.")
  2122. ;;; Result(192)  <==== #<INFERENCE-UNIT-TEST 0>
  2123. ;;; CYC(193): (DEFINE-INFERENCE-UNIT-TEST :GENL-RULES-ISA :OWNER "goolsbey" :KB :FULL :BUG 22453 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?HIGH #$Collection) (#$genls ?HIGH #$Individual) (#$isa ?MID #$Collection) (#$genls ?MID ?HIGH) (#$isa ?LOW #$Collection) (#$genls ?LOW ?MID) (#$collectionBackchainEncouraged ?HIGH) (#$collectionBackchainEncouraged ?MID) (#$collectionBackchainEncouraged ?LOW) (#$implies (#$equalSymbols ?X "a") (#$isa ?X ?MID)) (#$implies (#$and (#$performSubL (#$ExpandSubLFn (?X) (ABORT-CURRENT-CONTROLLING-INFERENCE))) (#$equalSymbols ?X "a")) (#$isa ?X ?LOW)) (#$genlRules (#$implies (#$and (#$performSubL (#$ExpandSubLFn (?X) (ABORT-CURRENT-CONTROLLING-INFERENCE))) (#$equalSymbols ?X "a")) (#$isa ?X ?LOW)) (#$implies (#$equalSymbols ?X "a") (#$isa ?X ?MID)))) (#$isa ?WHAT ?HIGH)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Due to the #$genlRules, the second more specific rule with the trap should be avoided.")
  2124. ;;; Result(193)  <==== #<INFERENCE-UNIT-TEST 0>
  2125. ;;; CYC(194): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-UNION-TRANSFORMATION :OWNER "goolsbey" :KB :TINY :BUG 22457 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$implies (#$integerBetween 1 ?N 2) (?P ?N ?N))) (#$or (?P 1 ?NUM) (?P 2 ?NUM))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that transformation works down union links.")
  2126. ;;; Result(194)  <==== #<INFERENCE-UNIT-TEST 0>
  2127. ;;; CYC(195): (DEFINE-INFERENCE-UNIT-TEST :NOT-SO-SIMPLE-UNION-TRANSFORMATION :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$implies (#$and (#$integerBetween 1 ?N 2) (#$integerBetween 1 ?N 3)) (?P ?N ?N))) (#$and (#$or (?P 1 ?NUM) (?P 2 ?NUM)) (#$quotedIsa ?NUM #$SubLInteger))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that N propagates down union links.")
  2128. ;;; Result(195)  <==== #<INFERENCE-UNIT-TEST 0>
  2129. ;;; CYC(196): (DEFINE-INFERENCE-UNIT-TEST :FIND-PROOF-JO-REUSE-RT :OWNER "goolsbey" :KB :TINY :BUG 22513 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$backchainRequired ?Q) (#$implies (?P ?N) (?Q ?N)) (?P 1) (?R 1) (?R 2) (?R 3) (?R 4)) (#$and (?Q ?X) (?R ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?X . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$trueSubL (#$SubLQuoteFn (= 1 (PROBLEM-PROOF-COUNT (FIND-PROBLEM-BY-ID (CURRENTLY-ACTIVE-PROBLEM-STORE) 0)))))) :EXPECTED-RESULT (NIL) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "The top-level problem should only get one RT proof
  2130.    not a second, redundant JO proof as well.")
  2131. ;;; Result(196)  <==== #<INFERENCE-UNIT-TEST 0>
  2132. ;;; CYC(197): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-DISJUNCTIVE-ASSUMPTION :OWNER "goolsbey" :KB :TINY :BUG 5465 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED1 #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?BASE #$UnaryPredicate) (#$implies (?BASE ?X) (#$or (?PRED1 ?X) (?PRED2 ?X))) (?BASE "a")) (#$or (?PRED1 ?WHAT) (?PRED2 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Demonstrate the ability to prove a simple disjunction
  2133.    without being able to prove either disjunct in isolation.")
  2134. ;;; Result(197)  <==== #<INFERENCE-UNIT-TEST 0>
  2135. ;;; CYC(198): (DEFINE-INFERENCE-UNIT-TEST :REJECT-UNWARRANTED-ASSUMPTION :OWNER "goolsbey" :KB :TINY :BUG 5465 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED1 #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?BASE #$UnaryPredicate) (#$implies (?BASE ?X) (#$or (?PRED1 ?X) (?PRED2 ?X))) (?BASE "a")) (#$or (?PRED1 ?WHAT) (?PRED2 ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (LIST (LIST :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED1 #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?BASE #$UnaryPredicate) (#$implies (?BASE ?X) (#$or (?PRED1 ?X) (?PRED2 ?X))) (?BASE "a")) (?PRED1 ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL)) :COMMENT "Demonstrate the ability to prove a simple disjunction
  2136.    without being able to prove either disjunct in isolation.")
  2137. ;;; Result(198)  <==== #<INFERENCE-UNIT-TEST 0>
  2138. ;;; CYC(199): (DEFINE-INFERENCE-UNIT-TEST :INTERMEDIATE-DISJUNCTION :OWNER "goolsbey" :KB :TINY :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?BOT #$UnaryPredicate) (#$isa ?MID1 #$UnaryPredicate) (#$isa ?MID2 #$UnaryPredicate) (#$isa ?TOP #$UnaryPredicate) (#$implies (?BOT ?X) (#$or (?MID1 ?X) (?MID2 ?X))) (#$implies (#$or (?MID1 ?X) (?MID2 ?X)) (?TOP ?X)) (?BOT "a")) (?TOP ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 10 :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Demonstrate the ability to prove via an intermediate disjunction")
  2139. ;;; Result(199)  <==== #<INFERENCE-UNIT-TEST 0>
  2140. ;;; CYC(200): (DEFINE-INFERENCE-UNIT-TEST :EARLY-REMOVAL-OF-8-RESTRICTED-PROBLEMS-REQUIRING-TRANSFORMATION :OWNER "jantos" :KB :TINY :BUG 22799 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?C #$Collection) (#$completelyEnumerableCollection ?C) (#$isa ?PRED #$BinaryPredicate) (#$isa ?C-1 #$Collection) (#$collectionBackchainRequired ?C-1) (#$isa ?C-1 ?C) (#$isa ?C-2 #$Collection) (#$collectionBackchainRequired ?C-2) (#$isa ?C-2 ?C) (#$isa ?C-3 #$Collection) (#$collectionBackchainRequired ?C-3) (#$isa ?C-3 ?C) (#$isa ?C-4 #$Collection) (#$collectionBackchainRequired ?C-4) (#$isa ?C-4 ?C) (#$isa ?C-5 #$Collection) (#$collectionBackchainRequired ?C-5) (#$isa ?C-5 ?C) (#$isa ?C-6 #$Collection) (#$collectionBackchainRequired ?C-6) (#$isa ?C-6 ?C) (#$isa ?C-7 #$Collection) (#$collectionBackchainRequired ?C-7) (#$isa ?C-7 ?C) (#$isa ?C-8 #$Collection) (#$collectionBackchainRequired ?C-8) (#$isa ?C-8 ?C) (#$isa ?PRED-1 #$BinaryPredicate) (#$isa ?D-1 #$Thing) (?PRED-1 ?D-1 1) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?D-2 #$Thing) (?PRED-2 ?D-2 1) (#$isa ?PRED-3 #$BinaryPredicate) (#$isa ?D-3 #$Thing) (?PRED-3 ?D-3 1) (#$isa ?PRED-4 #$BinaryPredicate) (#$isa ?D-4 #$Thing) (?PRED-4 ?D-4 1) (#$isa ?PRED-5 #$BinaryPredicate) (#$isa ?D-5 #$Thing) (?PRED-5 ?D-5 1) (#$isa ?PRED-6 #$BinaryPredicate) (#$isa ?D-6 #$Thing) (?PRED-6 ?D-6 1) (#$isa ?PRED-7 #$BinaryPredicate) (#$isa ?D-7 #$Thing) (?PRED-7 ?D-7 1) (#$isa ?PRED-8 #$BinaryPredicate) (#$isa ?D-8 #$Thing) (?PRED-8 ?D-8 1) (#$implies (#$and (?PRED-1 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-1)) (#$implies (#$and (?PRED-2 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-2)) (#$implies (#$and (?PRED-3 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-3)) (#$implies (#$and (?PRED-4 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-4)) (#$implies (#$and (?PRED-5 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-5)) (#$implies (#$and (?PRED-6 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-6)) (#$implies (#$and (?PRED-7 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-7)) (#$implies (#$and (?PRED-8 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-8))) (#$thereExists ?X (#$and (#$isa ?X ?C) (#$isa ?RESULT ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?RESULT . ?D-1)) ((?RESULT . ?D-2)) ((?RESULT . ?D-3)) ((?RESULT . ?D-4)) ((?RESULT . ?D-5)) ((?RESULT . ?D-6)) ((?RESULT . ?D-7)) ((?RESULT . ?D-8)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Early removal is required to give N motivation to 8 restricted problems that require T motivation since the non-focal is (#$isa ?X ?Y) and will not propagate T")
  2141. ;;; Result(200)  <==== #<INFERENCE-UNIT-TEST 0>
  2142. ;;; CYC(201): (DEFINE-INFERENCE-UNIT-TEST :EARLY-NEW-ROOT-OF-9-RESTRICTED-PROBLEMS-REQUIRING-TRANSFORMATION :OWNER "jantos" :KB :TINY :BUG 22799 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?C #$Collection) (#$completelyEnumerableCollection ?C) (#$isa ?PRED #$BinaryPredicate) (#$isa ?C-1 #$Collection) (#$collectionBackchainRequired ?C-1) (#$isa ?C-1 ?C) (#$isa ?C-2 #$Collection) (#$collectionBackchainRequired ?C-2) (#$isa ?C-2 ?C) (#$isa ?C-3 #$Collection) (#$collectionBackchainRequired ?C-3) (#$isa ?C-3 ?C) (#$isa ?C-4 #$Collection) (#$collectionBackchainRequired ?C-4) (#$isa ?C-4 ?C) (#$isa ?C-5 #$Collection) (#$collectionBackchainRequired ?C-5) (#$isa ?C-5 ?C) (#$isa ?C-6 #$Collection) (#$collectionBackchainRequired ?C-6) (#$isa ?C-6 ?C) (#$isa ?C-7 #$Collection) (#$collectionBackchainRequired ?C-7) (#$isa ?C-7 ?C) (#$isa ?C-8 #$Collection) (#$collectionBackchainRequired ?C-8) (#$isa ?C-8 ?C) (#$isa ?C-9 #$Collection) (#$collectionBackchainRequired ?C-9) (#$isa ?C-9 ?C) (#$isa ?PRED-1 #$BinaryPredicate) (#$isa ?D-1 #$Thing) (?PRED-1 ?D-1 1) (#$isa ?PRED-2 #$BinaryPredicate) (#$isa ?D-2 #$Thing) (?PRED-2 ?D-2 1) (#$isa ?PRED-3 #$BinaryPredicate) (#$isa ?D-3 #$Thing) (?PRED-3 ?D-3 1) (#$isa ?PRED-4 #$BinaryPredicate) (#$isa ?D-4 #$Thing) (?PRED-4 ?D-4 1) (#$isa ?PRED-5 #$BinaryPredicate) (#$isa ?D-5 #$Thing) (?PRED-5 ?D-5 1) (#$isa ?PRED-6 #$BinaryPredicate) (#$isa ?D-6 #$Thing) (?PRED-6 ?D-6 1) (#$isa ?PRED-7 #$BinaryPredicate) (#$isa ?D-7 #$Thing) (?PRED-7 ?D-7 1) (#$isa ?PRED-8 #$BinaryPredicate) (#$isa ?D-8 #$Thing) (?PRED-8 ?D-8 1) (#$isa ?PRED-9 #$BinaryPredicate) (#$isa ?D-9 #$Thing) (?PRED-9 ?D-9 1) (#$implies (#$and (?PRED-1 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-1)) (#$implies (#$and (?PRED-2 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-2)) (#$implies (#$and (?PRED-3 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-3)) (#$implies (#$and (?PRED-4 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-4)) (#$implies (#$and (?PRED-5 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-5)) (#$implies (#$and (?PRED-6 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-6)) (#$implies (#$and (?PRED-7 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-7)) (#$implies (#$and (?PRED-8 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-8)) (#$implies (#$and (?PRED-9 ?X ?N) (#$greaterThan ?N 0)) (#$isa ?X ?C-9))) (#$thereExists ?X (#$and (#$isa ?X ?C) (#$isa ?RESULT ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?RESULT . ?D-1)) ((?RESULT . ?D-2)) ((?RESULT . ?D-3)) ((?RESULT . ?D-4)) ((?RESULT . ?D-5)) ((?RESULT . ?D-6)) ((?RESULT . ?D-7)) ((?RESULT . ?D-8)) ((?RESULT . ?D-9)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Early transformation is required to give N motivation to 9 restricted problems that require T motivation since the non-focal is (#$isa ?X ?Y) and will not propagate T.
  2143. Previously since there are more than 8 restricted problems this query did not return bindings until bug 22799 was fixed.")
  2144. ;;; Result(201)  <==== #<INFERENCE-UNIT-TEST 0>
  2145. ;;; CYC(202): (DEFINE-INFERENCE-UNIT-TEST :PARTIALLY-COMMUTATIVE-UNIFICATION :OWNER "goolsbey" :KB :TINY :BUG 22899 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$TernaryPredicate) (#$commutativeInArgs ?PRED 2 3) (#$implies (#$elementOf ?X (#$TheSet "a" "b" "c")) (?PRED ?X ?X ?X))) (#$and (?PRED ?A ?B ?C) (#$elementOf ?B (#$TheSet "c" "d" "e")))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . "c") (?B . "c") (?C . "c")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "The partial commutivity module should not lead to a split in the residual transformed problem.")
  2146. ;;; Result(202)  <==== #<INFERENCE-UNIT-TEST 0>
  2147. ;;; CYC(203): (DEFINE-INFERENCE-UNIT-TEST :TERNARY-BACKCHAIN-WITH-UNIFICATION :OWNER "goolsbey" :KB :TINY :BUG 22899 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$TernaryPredicate) (#$implies (#$elementOf ?X (#$TheSet "a" "b" "c")) (?PRED ?X ?X ?X))) (#$and (?PRED ?A ?B ?C) (#$elementOf ?B (#$TheSet "c" "d" "e")))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?A . "c") (?B . "c") (?C . "c")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Transformation should not lead to a split in the residual transformed problem.")
  2148. ;;; Result(203)  <==== #<INFERENCE-UNIT-TEST 0>
  2149. ;;; CYC(204): :EOF
  2150. ;;; ... w:\cyc\top\tests\inference-transformation-test-cases.lisp loaded; SHA-1: 2b00f52162eb95f965be6a4461ec35c06478c5ae
  2151. ;;; loading w:\cyc\top\tests\forward-inference-unit-test-cases.lisp ...
  2152. ;;; CYC(1): (IN-PACKAGE "CYC")
  2153. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2154. ;;; CYC(2): (CVS-ID "$Id: forward-inference-unit-test-cases.lisp 126640 2008-12-04 13:39:36Z builder $")
  2155. ;;; Result(2)  <==== CL:NIL
  2156. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-QUINTARY-PREDICATE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?P #$QuintaryPredicate) (#$arity ?P 5)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that the forward #$QuintaryPredicate rule works.")
  2157. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2158. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-INDETERMINATE-RESULT :OWNER "jantos" :BUG 9801 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?TERM #$IndeterminateTerm) (?P ?TERM) (#$implies (?P ?X) (?Q ?X)) (#$assertionDirection (#$implies (?P ?X) (?Q ?X)) #$Forward-AssertionDirection)) (#$thereExists ?ANS (?Q ?ANS))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that forward inference allows
  2159.    conclusions about indeterminates.")
  2160. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2161. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-FORWARD-PRAGMATIC-REQUIREMENT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?LOGIC #$UnaryPredicate) (#$isa ?PROP #$UnaryPredicate) (?LOGIC 212) (?LOGIC 213) (#$implies (?LOGIC ?X) (?PROP ?X)) (#$pragmaticRequirement (#$equalSymbols ?X 212) (#$implies (?LOGIC ?X) (?PROP ?X))) (#$assertionDirection (#$implies (?LOGIC ?X) (?PROP ?X)) #$Forward-AssertionDirection)) (?PROP ?TERM)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?TERM . 212)))) :COMMENT "Test that ensures that #$pragmaticRequirement properly focuses forward inference.")
  2162. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2163. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-FORWARD-PRAGMATIC-REQUIREMENT-SUPPORTS :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?LOGIC #$UnaryPredicate) (#$isa ?PROP #$UnaryPredicate) (?LOGIC 212) (?LOGIC 213) (#$implies (?LOGIC ?X) (?PROP ?X)) (#$pragmaticRequirement (#$equalSymbols ?X 212) (#$implies (?LOGIC ?X) (?PROP ?X))) (#$assertionDirection (#$implies (?LOGIC ?X) (?PROP ?X)) #$Forward-AssertionDirection)) (#$evaluate ?LENGTH (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (DEDUCTION-SUPPORTS (FIRST (ASSERTION-ARGUMENTS (FIND-GAF-ANY-MT (QUOTE (?PROP 212))))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?LENGTH . 2)))) :COMMENT "Test that ensures that #$pragmaticRequirement properly omits the #$equalSymbols pragmaticRequirement from the supports.")
  2164. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2165. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :NART-ISA-IN-RIGHT-MT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?MT #$Microtheory) (#$isa ?FUNC #$UnaryFunction) (#$isa ?FUNC #$ReifiableFunction) (#$arg1Isa ?FUNC ?COL) (#$isa ?COL #$Collection) (#$isa ?TERM ?COL) (#$ist #$UniversalVocabularyMt (#$resultIsa ?FUNC #$Thing)) (#$ist ?MT (#$resultIsa ?FUNC ?COL)) (#$comment (?FUNC ?TERM) "think of this nart")) (#$ist-Asserted ?MT (#$isa (?FUNC ?TERM) ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that the forward-concluded #$isa assertion goes in the right mt.")
  2166. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2167. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHESIS-MT-SPLICING-RULE :OWNER "goolsbey" :WORKING? NIL :BUG 2504 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?INITIAL-STATE #$Microtheory) (#$genlMt ?INITIAL-STATE #$BaseKB) (#$isa ?TASK-5 #$Microtheory) (#$genlMt ?TASK-5 #$BaseKB) (#$ist #$BaseKB (#$forAll ?HYP-MT (#$implies (#$and (#$isa ?HYP-MT #$HypotheticalContext) (#$genlMt ?HYP-MT ?INITIAL-STATE)) (#$genlMt ?TASK-5 ?HYP-MT)))) (#$assertionDirection (#$ist #$BaseKB (#$forAll ?HYP-MT (#$implies (#$and (#$isa ?HYP-MT #$HypotheticalContext) (#$genlMt ?HYP-MT ?INITIAL-STATE)) (#$genlMt ?TASK-5 ?HYP-MT)))) #$Forward-AssertionDirection)) (#$equalSymbols ?MTS (#$TheSet ?INITIAL-STATE ?TASK-5))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (QUOTE (((?MTS #$TheSet ?INITIAL-STATE ?TASK-5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist ?INITIAL-STATE (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist ?INITIAL-STATE (?PRED 212))) (#$ist ?TASK-5 (?PRED ?WHAT)))) :PROPERTIES (:CONDITIONAL-SENTENCE? T) :EXPECTED-RESULT (((?WHAT . 212))) :EXPECTED-HALT-REASON :EXHAUST))) :COMMENT "This is a unit test for forward rule not fired when sufficient forward neg-lits generated")
  2168. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2169. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-PROBLEM-STORE-DESTRUCTION-ON-CONFLICT :OWNER "goolsbey" :BUG 5811 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$arg1Isa ?Q #$Collection) (#$isa ?TERM #$Individual) (?P ?TERM) (#$implies (#$and (?P ?N) (#$different ?N #$Collection)) (?Q ?N)) (#$assertionDirection (#$implies (#$and (?P ?N) (#$different ?N #$Collection)) (?Q ?N)) #$Forward-AssertionDirection)) #$False))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "This test triggers an abort of forward inference due to a deduction conflict.
  2170.    This should cause the forward problem store to be destroyed.  Therefore, the
  2171.    (problem-store-count) before and after this test should be the same.")
  2172. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2173. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-RULE-CONCLUDING-CONSEQUENT-IN-WRONG-MT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?MT #$Microtheory) (#$forAll ?X (#$implies (?P ?X) (#$ist ?MT (?Q ?X)))) (#$assertionDirection (#$forAll ?X (#$implies (?P ?X) (#$ist ?MT (?Q ?X)))) #$Forward-AssertionDirection) (?P #$Thing)) (#$ist-Asserted ?MT (?Q #$Thing))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT " ")
  2174. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2175. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-FORWARD-CONSTRAINT-SUCCESS :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED "a") (#$implies (?PRED ?X) (#$equalSymbols ?X "a")) (#$constraint (#$forAll ?X (#$implies (?PRED ?X) (#$equalSymbols ?X "a")))) (#$assertionDirection (#$forAll ?X (#$implies (?PRED ?X) (#$equalSymbols ?X "a"))) #$Forward-AssertionDirection)) (#$assertedSentence (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Simplest example of a forward #$constraint succeeding.")
  2176. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2177. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-FORWARD-CONSTRAINT-VIOLATION :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED "b") (#$implies (?PRED ?X) (#$equalSymbols ?X "a")) (#$constraint (#$forAll ?X (#$implies (?PRED ?X) (#$equalSymbols ?X "a")))) (#$assertionDirection (#$forAll ?X (#$implies (?PRED ?X) (#$equalSymbols ?X "a"))) #$Forward-AssertionDirection)) (#$assertedSentence (?PRED "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Simplest example of a forward #$constraint triggering a violation.")
  2178. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2179. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :SKOLEMIZE-FORWARD :OWNER "goolsbey" :BUG 11114 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?PRED #$UnaryPredicate) (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$skolemizeForward ?FUNC) (#$implies (#$isa ?OBJ ?COL) (?PRED (?FUNC ?OBJ))) (#$assertionDirection (#$implies (#$isa ?OBJ ?COL) (?PRED (?FUNC ?OBJ))) #$Forward-AssertionDirection)) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :BROWSABLE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT ?FUNC ?TERM)))) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CNOT (USELESS-NART? (FIND-NART (QUOTE (?FUNC ?TERM)))))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Forward inference should reify (?FUNC ?TERM) since ?FUNC is #$skolemizeForward.
  2180.    Furthermore, the NART should not be considered a 'useless NART' for the same reason.")
  2181. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2182. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :KAPPA-FORWARD-PROPAGATION :OWNER "kknight" :BUG 11227 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED1 #$BinaryPredicate) (#$isa ?PRED2 #$BinaryPredicate) (#$isa ?PRED3 #$TernaryPredicate) (#$genlPreds ?PRED1 (#$Kappa (?COL1 ?COL2) (?PRED3 ?PRED2 ?COL1 ?COL2)))) (?PRED ?PRED1 (#$Kappa (?COL1 ?COL2) (?PRED3 ?PRED2 ?COL1 ?COL2)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?PRED . #$genlPreds)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Make sure that forward propagation of the genlPreds GAF does
  2183.    not cause an error.")
  2184. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2185. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-RULES-ARE-SIMPLY-INDEXED-FORWARD :OWNER "pace" :KB :BOTH :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X)) (#$assertionDirection (#$implies (?P ?X) (?Q ?X)) #$Forward-AssertionDirection)) (#$trueSubL (#$ExpandSubLFn (?Q) (CAND (SIMPLE-INDEXED-TERM-P ?Q) (NULL (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :BACKWARD)) (SINGLETON? (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :FORWARD)))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "Ensure that forward rules are simply indexed as forward.")
  2186. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2187. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :BACKWARD-RULES-ARE-SIMPLY-INDEXED-BACKWARD :OWNER "pace" :KB :BOTH :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (?P ?X) (?Q ?X))) (#$trueSubL (#$ExpandSubLFn (?Q) (CAND (SIMPLE-INDEXED-TERM-P ?Q) (SINGLETON? (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :BACKWARD)) (NULL (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :FORWARD)))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "Ensure that backward rules are simply indexed as backward.")
  2188. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2189. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-RULES-ARE-COMPLEXLY-INDEXED-FORWARD :OWNER "pace" :KB :BOTH :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (?Q 7) (?Q 8) (?Q 9) (?Q 10) (?Q 11) (?Q 12) (?Q 13) (?Q 14) (?Q 15) (?Q 16) (?Q 17) (?Q 18) (?Q 19) (?Q 20) (?Q 21) (?Q 22) (?Q 23) (?Q 24) (?Q 25) (?Q 26) (?Q 27) (?Q 28) (?Q 29) (?Q 30) (#$implies (?P ?X) (?Q ?X)) (#$assertionDirection (#$implies (?P ?X) (?Q ?X)) #$Forward-AssertionDirection)) (#$trueSubL (#$ExpandSubLFn (?Q) (CAND (COMPLEX-INDEXED-TERM-P ?Q) (NULL (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :BACKWARD)) (SINGLETON? (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :FORWARD)))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "Ensure that forward rules are complexly indexed as forward.")
  2190. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2191. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :BACKWARD-RULES-ARE-COMPLEXLY-INDEXED-BACKWARD :OWNER "pace" :KB :BOTH :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (?Q 7) (?Q 8) (?Q 9) (?Q 10) (?Q 11) (?Q 12) (?Q 13) (?Q 14) (?Q 15) (?Q 16) (?Q 17) (?Q 18) (?Q 19) (?Q 20) (?Q 21) (?Q 22) (?Q 23) (?Q 24) (?Q 25) (?Q 26) (?Q 27) (?Q 28) (?Q 29) (?Q 30) (#$implies (?P ?X) (?Q ?X))) (#$trueSubL (#$ExpandSubLFn (?Q) (CAND (COMPLEX-INDEXED-TERM-P ?Q) (SINGLETON? (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :BACKWARD)) (NULL (GATHER-PREDICATE-RULE-INDEX-IN-ALL-MTS ?Q :POS :FORWARD)))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :COMMENT "Ensure that backward rules are complexly indexed as backward.")
  2192. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2193. ;;; CYC(19): :EOF
  2194. ;;; ... w:\cyc\top\tests\forward-inference-unit-test-cases.lisp loaded; SHA-1: af87f439c84e446378f372011e1d0020095cefe0
  2195. ;;; loading w:\cyc\top\tests\inference-completeness-unit-test-cases.lisp ...
  2196. ;;; CYC(1): (IN-PACKAGE "CYC")
  2197. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2198. ;;; CYC(2): (CVS-ID "$Id: inference-completeness-unit-test-cases.lisp 129049 2009-10-28 15:38:24Z pace $")
  2199. ;;; Result(2)  <==== CL:NIL
  2200. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-OPEN-COMPLETE-EXTENT-ASSERTED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentAsserted ?PRED)) (#$and (?PRED ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "After failing to look up (?PRED ?WHAT), it completely prunes the other branch.")
  2201. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2202. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ENUMERABLE-WITH-ONLY-LOOKUP :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerable ?PRED)) (#$and (?PRED ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Test that once it fails on lookup of (?PRED ?WHAT),
  2203. it has to set aside the other branch instead of throw it away,
  2204. because #$completeExtentEnumerable is not as strong as #$completeExtentAsserted.
  2205. Differs from @xref :prune-open-complete-extent-asserted
  2206. in the hypothesis and expected halt reason.")
  2207. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2208. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-ASSERTED-FOR-VALUE-IN-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentAssertedForValueInArg ?PRED "a" 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "After failing to look up (?PRED a ?WHAT), it completely prunes the other branch.")
  2209. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2210. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ASSERTED-FOR-VALUE-IN-WRONG-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentAssertedForValueInArg ?PRED "a" 2)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-asserted-for-value-in-arg
  2211. in the hypothesis and the expected halt reason.")
  2212. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2213. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ASSERTED-FOR-WRONG-VALUE-IN-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentAssertedForValueInArg ?PRED "b" 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-asserted-for-value-in-arg
  2214. in the hypothesis and the expected halt reason.")
  2215. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2216. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-VALUE-IN-ARG-WITH-ONLY-LOOKUP :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForValueInArg ?PRED "a" 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T :ALLOWED-MODULES (:OR :DETERMINE-NEW-TRANSFORMATION-TACTICS :DETERMINE-NEW-SPLIT-TACTICS :SPLIT :REMOVAL-LOOKUP-POS :REMOVAL-EVAL))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from :prune-complete-extent-asserted-for-value-in-arg
  2217. in the properties and the expected halt reason.")
  2218. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2219. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-ENUMERABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerable ?PRED)) (#$and (?PRED ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that once it fails on lookup of (?PRED ?WHAT),
  2220. it can prune the other branch because of #$completeExtentEnumerable.")
  2221. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2222. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-DECIDABLE-UNBOUND :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentDecidable ?PRED)) (#$and (?PRED ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "After failing to solve (?PRED ?WHAT), it can still completely prune
  2223. the other branch (and abort) even with just completeExtentDecidable
  2224. because there's no way the conjunction can be solved.")
  2225. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2226. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ASSERTED-IMPLIES-PRUNE-COMPLETE-EXTENT-ENUMERABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentAsserted ?PRED)) (#$and (?PRED ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Exactly like @xref :prune-complete-extent-enumerable except we hypothesize
  2227. #$completeExtentAsserted, which is stronger than #$completeExtentEnumerable.")
  2228. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2229. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForArg ?PRED 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "After failing to solve (?PRED a ?WHAT), it can completely prune
  2230. the other branch because of #$completeExtentEnumerableForArg 1.")
  2231. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2232. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-WRONG-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForArg ?PRED 2)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-arg
  2233. in the hypothesis and the expected halt reason.")
  2234. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2235. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-DECIDABLE-UNBOUND-ARG2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentDecidable ?PRED)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-arg
  2236. in the hypothesis.")
  2237. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2238. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-INCOMPLETE-UNBOUND-ARG2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-arg
  2239. in the hypothesis and the expected halt reason.")
  2240. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2241. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ENUMERABLE-IMPLIES-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerable ?PRED)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Exactly like @xref :prune-complete-extent-enumerable-for-arg except we hypothesize
  2242. a strictly stronger assumption.")
  2243. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2244. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-VALUE-IN-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForValueInArg ?PRED "a" 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "After failing to solve (?PRED a ?WHAT), it can completely prune
  2245. the other branch because of the #$completeExtentEnumerableForValueInArg assertion.")
  2246. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2247. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-VALUE-IN-WRONG-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForValueInArg ?PRED "a" 2)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-value-in-arg
  2248. in the hypothesis and the expected halt reason.")
  2249. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2250. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-WRONG-VALUE-IN-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForValueInArg ?PRED "b" 1)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-value-in-arg
  2251. in the hypothesis and the expected halt reason.")
  2252. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  2253. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETE-EXTENT-DECIDABLE-FOR-VALUE-IN-ARG-UNBOUND-ARG2 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentDecidableForValueInArg ?PRED "a" 2)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Differs from @xref :prune-complete-extent-enumerable-for-value-in-arg
  2254. in the hypothesis and the expected halt reason.")
  2255. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  2256. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ENUMERABLE-IMPLIES-PRUNE-COMPLETE-EXTENT-ENUMERABLE-FOR-VALUE-IN-ARG :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerable ?PRED)) (#$and (?PRED "a" ?WHAT) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Exactly like @xref :prune-complete-extent-enumerable-for-value-in-arg except
  2257. we hypothesize a strictly stronger assumption.")
  2258. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  2259. ;;; CYC(22): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-COMPLETELY-ENUMERABLE-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completelyEnumerableCollection ?COL)) (#$and (#$isa ?WHAT ?COL) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that once it fails on lookup of (#$isa ?WHAT ?COL),
  2260. it can completely prune the other branch because of #$completelyEnumerableCollection.")
  2261. ;;; Result(22)  <==== #<INFERENCE-UNIT-TEST 0>
  2262. ;;; CYC(23): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-COMPLETELY-DECIDABLE-COLLECTION-UNBOUND :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completelyDecidableCollection ?COL)) (#$and (#$isa ?WHAT ?COL) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :COMMENT "Test that once it fails on lookup of (#$isa ?WHAT ?COL),
  2263. it can't completely prune the other branch because
  2264. #$completelyDecidableCollection is not as strong as #$completelyEnumerableCollection.
  2265. Differs from @xref :prune-completely-enumerable-collection in the hypothesis
  2266. and expected halt reason.")
  2267. ;;; Result(23)  <==== #<INFERENCE-UNIT-TEST 0>
  2268. ;;; CYC(24): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ENUMERABLE-FOR-ISA-COL-2-IMPLIES-PRUNE-COMPLETELY-ENUMERABLE-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$isa ?CHAFF #$UnaryPredicate) (?CHAFF 212) (#$completeExtentEnumerableForValueInArg #$isa ?COL 2)) (#$and (#$isa ?WHAT ?COL) (?CHAFF ?WHAT-ELSE))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 0 :CONTINUABLE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Exactly like :prune-completely-enumerable-collection except we hypothesize
  2269. a different but ostensibly equivalent constraint.")
  2270. ;;; Result(24)  <==== #<INFERENCE-UNIT-TEST 0>
  2271. ;;; CYC(25): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-COMPLETE-EXTENT-ASSERTED-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentAsserted ?PRED)) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can prove a negation by using #$completeExtentAsserted.")
  2272. ;;; Result(25)  <==== #<INFERENCE-UNIT-TEST 0>
  2273. ;;; CYC(26): (DEFINE-INFERENCE-UNIT-TEST :CLOSED-COMPLETE-EXTENT-ASSERTED-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentAsserted ?PRED) (?PRED "a")) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentAsserted
  2274. when the positive assertion is in the KB.
  2275. Differs from @xref :closed-complete-extent-asserted-negation-provable in the
  2276. hypothesis and the expected result.")
  2277. ;;; Result(26)  <==== #<INFERENCE-UNIT-TEST 0>
  2278. ;;; CYC(27): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ASSERTED-FOR-VALUE-IN-ARG-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentAssertedForValueInArg ?PRED "a" 1)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can prove a negation by using #$completeExtentAssertedForValueInArg.")
  2279. ;;; Result(27)  <==== #<INFERENCE-UNIT-TEST 0>
  2280. ;;; CYC(28): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ASSERTED-FOR-VALUE-IN-WRONG-ARG-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentAssertedForValueInArg ?PRED "a" 2)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentAssertedForValueInArg
  2281. when the target value appears in the wrong argnum.
  2282. Differs from @xref :complete-extent-asserted-for-value-in-arg-negation-provable
  2283. in the hypothesis and the expected result.")
  2284. ;;; Result(28)  <==== #<INFERENCE-UNIT-TEST 0>
  2285. ;;; CYC(29): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ASSERTED-FOR-WRONG-VALUE-IN-ARG-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentAssertedForValueInArg ?PRED "b" 1)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentAssertedForValueInArg
  2286. when the wrong value appears in the right argnum.
  2287. Differs from @xref :complete-extent-asserted-for-value-in-arg-negation-provable
  2288. in the hypothesis and the expected result.")
  2289. ;;; Result(29)  <==== #<INFERENCE-UNIT-TEST 0>
  2290. ;;; CYC(30): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ASSERTED-IMPLIES-COMPLETE-EXTENT-ASSERTED-FOR-VALUE-IN-ARG-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentAsserted ?PRED)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Exactly like @xref :complete-extent-asserted-for-value-in-arg-negation-provable
  2291. except we hypothesize a strictly stronger assumption.")
  2292. ;;; Result(30)  <==== #<INFERENCE-UNIT-TEST 0>
  2293. ;;; CYC(31): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentDecidable ?PRED)) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can prove a negation by using #$completeExtentDecidable.")
  2294. ;;; Result(31)  <==== #<INFERENCE-UNIT-TEST 0>
  2295. ;;; CYC(32): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentDecidable ?PRED) (?PRED "a")) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentDecidable
  2296. when the positive assertion is in the KB.
  2297. Differs from @xref :complete-extent-decidable-negation-provable in the
  2298. hypothesis and the expected result.")
  2299. ;;; Result(32)  <==== #<INFERENCE-UNIT-TEST 0>
  2300. ;;; CYC(33): (DEFINE-INFERENCE-UNIT-TEST :NOT-EVERYTHING-IS-COMPLETE-EXTENT-DECIDABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?PRED #$UnaryPredicate) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove arbitrary negations when we don't have
  2301. any meta-knowledge about completeness, e.g. #$completeExtentDecidable.
  2302. This should be a no-brainer.
  2303. Differs from @xref :complete-extent-decidable-negation-provable in the
  2304. hypothesis and the expected result.")
  2305. ;;; Result(33)  <==== #<INFERENCE-UNIT-TEST 0>
  2306. ;;; CYC(34): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-ENUMERABLE-IMPLIES-COMPLETE-EXTENT-DECIDABLE-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentEnumerable ?PRED)) (#$not (?PRED "a"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Exactly like @xref :complete-extent-decidable-negation-provable except we hypothesize
  2307. a strictly stronger assumption.")
  2308. ;;; Result(34)  <==== #<INFERENCE-UNIT-TEST 0>
  2309. ;;; CYC(35): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-FOR-VALUE-IN-ARG-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentDecidableForValueInArg ?PRED "a" 1)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can prove a negation by using #$completeExtentDecidableForValueInArg.")
  2310. ;;; Result(35)  <==== #<INFERENCE-UNIT-TEST 0>
  2311. ;;; CYC(36): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-FOR-VALUE-IN-WRONG-ARG-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentDecidableForValueInArg ?PRED "a" 2)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentDecidableForValueInArg
  2312. when the target value appears in the wrong argnum.
  2313. Differs from @xref :complete-extent-decidable-for-value-in-arg-negation-provable
  2314. in the hypothesis and the expected result.")
  2315. ;;; Result(36)  <==== #<INFERENCE-UNIT-TEST 0>
  2316. ;;; CYC(37): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-FOR-WRONG-VALUE-ARG-NEGATION-UNPROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentDecidableForValueInArg ?PRED "b" 1)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove a negation by using #$completeExtentDecidableForValueInArg
  2317. when the wrong value appears in the right argnum.
  2318. Differs from @xref :complete-extent-decidable-for-value-in-arg-negation-provable
  2319. in the hypothesis and the expected result.")
  2320. ;;; Result(37)  <==== #<INFERENCE-UNIT-TEST 0>
  2321. ;;; CYC(38): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-IMPLIES-COMPLETE-EXTENT-DECIDABLE-FOR-VALUE-IN-ARG-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentDecidable ?PRED)) (#$not (?PRED "a" "b"))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Exactly like @xref :complete-extent-decidable-for-value-in-arg-negation-provable
  2322. except we hypothesize a strictly stronger assumption.")
  2323. ;;; Result(38)  <==== #<INFERENCE-UNIT-TEST 0>
  2324. ;;; CYC(39): (DEFINE-INFERENCE-UNIT-TEST :COMPLETELY-DECIDABLE-COLLECTION-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$completelyDecidableCollection ?COL)) (#$not (#$isa "a" ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can prove a negation by using #$completelyDecidableCollection.")
  2325. ;;; Result(39)  <==== #<INFERENCE-UNIT-TEST 0>
  2326. ;;; CYC(40): (DEFINE-INFERENCE-UNIT-TEST :NOT-EVERY-COLLECTION-IS-COMPLETELY-DECIDABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?COL #$Collection) (#$not (#$isa "a" ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that we can't prove negated membership in an arbitrary collection.
  2327. Should be a no-brainer.")
  2328. ;;; Result(40)  <==== #<INFERENCE-UNIT-TEST 0>
  2329. ;;; CYC(41): (DEFINE-INFERENCE-UNIT-TEST :COMPLETE-EXTENT-DECIDABLE-ISA-COL-2-IMPLIES-COMPLETELY-DECIDABLE-COLLECTION-NEGATION-PROVABLE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$completeExtentDecidableForValueInArg #$isa ?COL 2)) (#$not (#$isa "a" ?COL))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Exactly like @xref :completely-decidable-collection-negation-provable
  2330. except we hypothesize a different but ostensibly equivalent constraint.")
  2331. ;;; Result(41)  <==== #<INFERENCE-UNIT-TEST 0>
  2332. ;;; CYC(42): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-INFERENCE-WITH-DEFNS :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) (#$assertionDirection (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) #$Forward-AssertionDirection)) (?R "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that this forward inference works without bringing completeness
  2333. into play.  This is the control for the following experiments.")
  2334. ;;; Result(42)  <==== #<INFERENCE-UNIT-TEST 0>
  2335. ;;; CYC(43): (DEFINE-INFERENCE-UNIT-TEST :COMPLETENESS-IN-LOW-MT-DOESNT-HOSE-FORWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$isa ?CLOSED-WORLD-MT #$Microtheory) (#$ist ?CLOSED-WORLD-MT (#$completelyEnumerableCollection ?STRING)) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) (#$assertionDirection (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) #$Forward-AssertionDirection)) (?R "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that asserting strong completeness assumptions in some low mt
  2336. doesn't totally hose forward inference.")
  2337. ;;; Result(43)  <==== #<INFERENCE-UNIT-TEST 0>
  2338. ;;; CYC(44): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-MT-COMPLETENESS-ASSERTION-DOESNT-HOSE-FORWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$completelyEnumerableCollection ?STRING) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) (#$assertionDirection (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) #$Forward-AssertionDirection)) (?R "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Exactly like @xref :completeness-in-low-mt-doesnt-hose-forward-inference
  2339. except asserts the brain-dead completeness assertion in the hypothetical
  2340. mt, not in an irrelevant lower mt.  Forward inference treats these two
  2341. cases the same, because it has to be conservative wrt completeness information.
  2342. Forward inference only uses completeness information that is universally true, not
  2343. hypothetically true.  It would be nice if this test yielded answers,
  2344. but for now, we simply test for the expected behaviour.")
  2345. ;;; Result(44)  <==== #<INFERENCE-UNIT-TEST 0>
  2346. ;;; CYC(45): (DEFINE-INFERENCE-UNIT-TEST :UNIVERSAL-COMPLETENESS-ASSERTION-HOSES-FORWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$ist #$BaseKB (#$completelyEnumerableCollection ?STRING)) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) (#$assertionDirection (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X)) #$Forward-AssertionDirection)) (?R "a")))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Exactly like @xref :completeness-in-low-mt-doesnt-hose-forward-inference
  2347. except asserts the brain-dead completeness assertion in #$BaseKB,
  2348. not in an irrelevant lower mt, and is expected to yield no answers.
  2349. If forward inference is respecting universally true #$completelyEnumerableCollection
  2350. assertions, this test should yield no answers.")
  2351. ;;; Result(45)  <==== #<INFERENCE-UNIT-TEST 0>
  2352. ;;; CYC(46): (DEFINE-INFERENCE-UNIT-TEST :COMPLETENESS-IN-LOW-MT-DOESNT-HOSE-BACKWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$isa ?CLOSED-WORLD-MT #$Microtheory) (#$ist ?CLOSED-WORLD-MT (#$completelyEnumerableCollection ?STRING)) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X))) (#$ist #$InferencePSC (?R ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that asserting strong completeness assumptions in some low mt
  2353. doesn't totally hose backward inference in #$InferencePSC.")
  2354. ;;; Result(46)  <==== #<INFERENCE-UNIT-TEST 0>
  2355. ;;; CYC(47): (DEFINE-INFERENCE-UNIT-TEST :HYPOTHETICAL-MT-COMPLETENESS-ASSERTION-DOESNT-HOSE-BACKWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$completelyEnumerableCollection ?STRING) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X))) (#$ist #$InferencePSC (?R ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Exactly like @xref :hypothetical-mt-completeness-assertion-doesnt-hose-forward-inference
  2356. except asks a backward inference in #$InferencePSC.")
  2357. ;;; Result(47)  <==== #<INFERENCE-UNIT-TEST 0>
  2358. ;;; CYC(48): (DEFINE-INFERENCE-UNIT-TEST :UNIVERSAL-COMPLETENESS-ASSERTION-HOSES-BACKWARD-INFERENCE :OWNER "pace" :BUG 9646 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?STRING #$Collection) (#$defnIff ?STRING (#$SubLQuoteFn SUBL-STRING-P)) (#$ist #$BaseKB (#$completelyEnumerableCollection ?STRING)) (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (?P "a") (?Q "a") (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (?P 6) (?Q 1) (?Q 2) (?Q 3) (?Q 4) (?Q 5) (?Q 6) (#$isa ?STRING1 ?STRING) (#$isa ?STRING2 ?STRING) (#$isa ?STRING3 ?STRING) (#$implies (#$and (?P ?X) (?Q ?X) (#$isa ?X ?STRING)) (?R ?X))) (#$ist #$InferencePSC (?R ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Exactly like @xref :universal-completeness-assertion-hoses-forward-inference
  2359. except asks a backward inference in #$InferencePSC.")
  2360. ;;; Result(48)  <==== #<INFERENCE-UNIT-TEST 0>
  2361. ;;; CYC(49): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-IN-LOW-MT-DOESNT-HOSE-BACKWARD-INFERENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?APP-SPECIFIC-MT #$Microtheory) (#$ist ?APP-SPECIFIC-MT (#$backchainRequired ?P)) (?P "a")) (#$ist #$EverythingPSC (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that asserting #$backchainRequired in some low mt
  2362. doesn't totally hose backward inference in #$EverythingPSC.
  2363. This is not really a completeness unit test, but it's in this file
  2364. because it's conceptually similar to :completeness-in-low-mt-doesnt-hose-backward-inference.")
  2365. ;;; Result(49)  <==== #<INFERENCE-UNIT-TEST 0>
  2366. ;;; CYC(50): (DEFINE-INFERENCE-UNIT-TEST :BACKCHAIN-REQUIRED-IN-HIGH-MT-HOSES-BACKWARD-INFERENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (#$backchainRequired ?P)) (?P "a")) (#$ist #$EverythingPSC (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that asserting #$backchainRequired in #$UniversalVocabularyMt
  2367. correctly inhibits removal in #$EverythingPSC.")
  2368. ;;; Result(50)  <==== #<INFERENCE-UNIT-TEST 0>
  2369. ;;; CYC(51): (DEFINE-INFERENCE-UNIT-TEST :EXCEPT-MT-IN-LOW-MT-DOESNT-HOSE-BACKWARD-INFERENCE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?OTHER-MT #$Microtheory) (#$isa ?APP-SPECIFIC-MT #$Microtheory) (#$ist ?APP-SPECIFIC-MT (?P "a")) (#$ist ?OTHER-MT (#$exceptMt ?APP-SPECIFIC-MT))) (#$ist #$EverythingPSC (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :COMMENT "Test that asserting #$exceptMt in some low mt
  2370. doesn't totally hose backward inference in #$EverythingPSC.
  2371. This is not really a completeness unit test, but it's in this file
  2372. because it's conceptually similar to :completeness-in-low-mt-doesnt-hose-backward-inference.")
  2373. ;;; Result(51)  <==== #<INFERENCE-UNIT-TEST 0>
  2374. ;;; CYC(52): (DEFINE-INFERENCE-UNIT-TEST :EXCEPT-MT-IN-MID-MT-BLOCKS-HIGH-MT-FROM-LOW-MT :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?HIGH-MT #$Microtheory) (#$isa ?MID-MT #$Microtheory) (#$isa ?LOW-MT #$Microtheory) (#$genlMt ?MID-MT ?HIGH-MT) (#$genlMt ?LOW-MT ?MID-MT) (#$ist ?HIGH-MT (?P "a")) (#$ist ?MID-MT (#$exceptMt ?HIGH-MT))) (#$ist ?LOW-MT (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that asserting #$exceptMt in a middle mt
  2375. correctly inhibits removal in a lower mt.")
  2376. ;;; Result(52)  <==== #<INFERENCE-UNIT-TEST 0>
  2377. ;;; CYC(53): (DEFINE-INFERENCE-UNIT-TEST :EXCEPT-MT-IN-MID-MT-BLOCKS-LOW-MT-FROM-ALL-MTS :OWNER "goolsbey" :WORKING? NIL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?MID-MT #$Microtheory) (#$isa ?LOW-MT #$Microtheory) (#$genlMt ?LOW-MT ?MID-MT) (#$ist ?HIGH-MT (#$exceptMt ?LOW-MT)) (#$ist ?LOW-MT (?P "a"))) (#$ist #$EverythingPSC (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that asserting #$exceptMt in a high mt
  2378. correctly blocks relevant lower mt assertions in #$EverythingPSC.")
  2379. ;;; Result(53)  <==== #<INFERENCE-UNIT-TEST 0>
  2380. ;;; CYC(54): (DEFINE-INFERENCE-UNIT-TEST :EXCEPT-MT-IN-HIGH-MT-HOSES-BACKWARD-INFERENCE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?OTHER-MT #$Microtheory) (#$isa ?APP-SPECIFIC-MT #$Microtheory) (#$ist ?APP-SPECIFIC-MT (?P "a")) (#$ist #$UniversalVocabularyMt (#$exceptMt ?APP-SPECIFIC-MT))) (#$ist #$EverythingPSC (?P ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that asserting #$exceptMt in #$UniversalVocabularyMt
  2381. correctly inhibits removal in #$EverythingPSC.")
  2382. ;;; Result(54)  <==== #<INFERENCE-UNIT-TEST 0>
  2383. ;;; CYC(55): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-COMPLETE-UNIVERSAL-IMPLICATION-VIA-ENUMERATION :OWNER "goolsbey" :BUG 22500 :SENTENCE (QUOTE (#$ist #$BaseKB (#$trueSentence (#$forAll ?N (#$implies (#$elementOf ?N (#$TheSet 0 1)) (#$evaluate ?N (#$TimesFn ?N ?N))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a complete universal implication can be proven by enumerate and test.")
  2384. ;;; Result(55)  <==== #<INFERENCE-UNIT-TEST 0>
  2385. ;;; CYC(56): (DEFINE-INFERENCE-UNIT-TEST :ALL-US-STATES-ARE-SUBDIVISIONS-OF-THE-US :OWNER "goolsbey" :BUG 22500 :KB :FULL :SENTENCE (QUOTE (#$ist #$UnitedStatesGeographyMt (#$trueSentence (#$forAll ?STATE (#$implies (#$isa ?STATE #$State-UnitedStates) (#$geopoliticalSubdivision #$UnitedStatesOfAmerica ?STATE)))))) :PROPERTIES (QUOTE (:CONTINUABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a complete universal implication can be proven by enumerate and test.")
  2386. ;;; Result(56)  <==== #<INFERENCE-UNIT-TEST 0>
  2387. ;;; CYC(57): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-ANTECEDENT-CONJUNCTION :OWNER "goolsbey" :BUG 22500 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$trueSentence (#$forAll ?N (#$implies (#$and (#$different ?N 2) (#$elementOf ?N (#$TheSet 0 1 2))) (#$evaluate ?N (#$TimesFn ?N ?N))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a complete conjunction in the antecedent can be enumerated.")
  2388. ;;; Result(57)  <==== #<INFERENCE-UNIT-TEST 0>
  2389. ;;; CYC(58): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-CONSEQ-CONJUNCTION :OWNER "goolsbey" :BUG 22500 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$trueSentence (#$forAll ?N (#$implies (#$elementOf ?N (#$TheSet 0 2)) (#$thereExists ?ANS (#$and (#$evaluate ?ANS (#$PlusFn ?N ?N)) (#$evaluate ?ANS (#$TimesFn ?N ?N))))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a complete antecedent with a conjunctive consequent can be enumerated.")
  2390. ;;; Result(58)  <==== #<INFERENCE-UNIT-TEST 0>
  2391. ;;; CYC(59): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-ANTE-CONJ-AND-CONSEQ-CONJ :OWNER "goolsbey" :BUG 22500 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$trueSentence (#$forAll ?N (#$implies (#$and (#$different ?N 1) (#$elementOf ?N (#$TheSet 0 1 2))) (#$thereExists ?ANS (#$and (#$evaluate ?ANS (#$PlusFn ?N ?N)) (#$evaluate ?ANS (#$TimesFn ?N ?N))))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a complete conjunction in the antecedent
  2392.    with a conjunctive consequent can be enumerated.")
  2393. ;;; Result(59)  <==== #<INFERENCE-UNIT-TEST 0>
  2394. ;;; CYC(60): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-BACKCHAIN-ANTE :OWNER "goolsbey" :BUG 22500 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$backchainRequired ?PRED) (#$completeExtentEnumerableViaBackchain ?PRED) (#$implies (#$elementOf ?N (#$TheSet 0 1)) (?PRED ?N))) (#$trueSentence (#$forAll ?NUM (#$implies (?PRED ?NUM) (#$evaluate ?NUM (#$TimesFn ?NUM ?NUM)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :TRANSFORMATION-ALLOWED? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a predicate that is completely enumerable via backchain
  2395.    in the antecedent can be enumerated in a universal implication.")
  2396. ;;; Result(60)  <==== #<INFERENCE-UNIT-TEST 0>
  2397. ;;; CYC(61): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-BACKCHAIN-COL-ANTE :OWNER "goolsbey" :BUG 22500 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$collectionBackchainRequired ?COL) (#$collectionCompletelyEnumerableViaBackchain ?COL) (#$implies (#$elementOf ?N (#$TheSet 0 1)) (#$isa ?N ?COL))) (#$trueSentence (#$forAll ?NUM (#$implies (#$isa ?NUM ?COL) (#$evaluate ?NUM (#$TimesFn ?NUM ?NUM)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :TRANSFORMATION-ALLOWED? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a collection that is completely enumerable via backchain
  2398.    in the antecedent can be enumerated in a universal implication.")
  2399. ;;; Result(61)  <==== #<INFERENCE-UNIT-TEST 0>
  2400. ;;; CYC(62): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-BACKCHAIN-CONSEQ :OWNER "goolsbey" :BUG 22500 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$backchainRequired ?PRED) (#$completeExtentEnumerableViaBackchain ?PRED) (#$implies (#$elementOf ?N (#$TheSet 0 1 2)) (?PRED ?N))) (#$trueSentence (#$forAll ?NUM (#$implies (#$elementOf ?NUM (#$TheSet 0 1)) (?PRED ?NUM))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a predicate that is completely enumerable via backchain
  2401.    in the consequent can be determined in a universal implication.")
  2402. ;;; Result(62)  <==== #<INFERENCE-UNIT-TEST 0>
  2403. ;;; CYC(63): (DEFINE-INFERENCE-UNIT-TEST :COMP-UNIV-IMP-VIA-ENUM-BACKCHAIN-COL-CONSEQ :OWNER "goolsbey" :BUG 22500 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$collectionBackchainRequired ?COL) (#$collectionCompletelyEnumerableViaBackchain ?COL) (#$implies (#$elementOf ?N (#$TheSet 0 1 2)) (#$isa ?N ?COL))) (#$trueSentence (#$forAll ?NUM (#$implies (#$elementOf ?NUM (#$TheSet 0 1)) (#$isa ?NUM ?COL))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a collection that is completely enumerable via backchain
  2404.    in the consequent can be determined in a universal implication.")
  2405. ;;; Result(63)  <==== #<INFERENCE-UNIT-TEST 0>
  2406. ;;; CYC(64): (DEFINE-INFERENCE-UNIT-TEST :NEG-ENUMERABLE-NOT-COMPLETE :OWNER "goolsbey" :BUG 22955 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$completeExtentEnumerable ?PRED) (?PRED 1)) (#$and (#$elementOf ?X (#$TheSet 1 2 3 4 5)) (#$not (?PRED ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that a completely enumerable predicate in a negative literal
  2407.    is not deemed complete via meta-removal modules.")
  2408. ;;; Result(64)  <==== #<INFERENCE-UNIT-TEST 0>
  2409. ;;; CYC(65): (DEFINE-INFERENCE-UNIT-TEST :GROSSLY-DISPREFER-NEG :OWNER "goolsbey" :BUG 22956 :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?P #$UnaryPredicate) (?P 1) (?P 2) (?P 3) (?P 4) (?P 5) (#$isa ?Q #$UnaryPredicate) (#$completeExtentEnumerable ?Q) (?Q 1)) (#$and (?P ?X) (#$not (?Q ?X)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)) ((?X . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that an open negative literal is grossly dispreferred.")
  2410. ;;; Result(65)  <==== #<INFERENCE-UNIT-TEST 0>
  2411. ;;; CYC(66): :EOF
  2412. ;;; ... w:\cyc\top\tests\inference-completeness-unit-test-cases.lisp loaded; SHA-1: 6b38f304c1a58b88205c49a0a199a0f92e91d419
  2413. ;;; loading w:\cyc\top\tests\inference-proof-spec-test-cases.lisp ...
  2414. ;;; CYC(1): (IN-PACKAGE :CYC)
  2415. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2416. ;;; CYC(2): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-REMOVAL-PROOF-SPEC-1 :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection))) :PROPERTIES (QUOTE (:PROOF-SPEC (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection)) :REMOVAL-ISA-COLLECTION-CHECK-POS))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensures that we can solve a simple removal with a proof spec.")
  2417. ;;; Result(2)  <==== #<INFERENCE-UNIT-TEST 0>
  2418. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-REMOVAL-PROOF-SPEC-2 :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection))) :PROPERTIES (QUOTE (:PROOF-SPEC (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection)) :REMOVAL-ALL-ISA))) :EXPECTED-RESULT NIL :COMMENT "Ensures that we fail when given the wrong removal module in the proof-spec.")
  2419. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2420. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-OPEN-REMOVAL-PROOF-SPEC :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa ?X #$LogicalConnective))) :PROPERTIES (QUOTE (:PROOF-SPEC (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa :ANYTHING #$LogicalConnective)) :REMOVAL-ALL-INSTANCES))) :EXPECTED-RESULT (QUOTE (((?X . #$and)) ((?X . #$or)) ((?X . #$not)) ((?X . #$implies)) ((?X . #$xor)) ((?X . #$equiv)) ((?X . #$nand)) ((?X . #$nor)))) :COMMENT "Ensures that we can solve a simple removal with a proof spec.")
  2421. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2422. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-SPLIT-PROOF-SPEC :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$isa #$isa #$Individual) (#$isa #$Thing #$Collection)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:SPLIT (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection)) :REMOVAL-ISA-COLLECTION-CHECK-POS) (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa #$isa #$Individual)) :REMOVAL-ISA-COLLECTION-CHECK-POS)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensures that we can solve a simple split into two removal checks with a proof spec.")
  2423. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2424. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-ORDERED-PROOF-SPEC :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 1) (#$integerBetween 0 ?X 200)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 1)) :REMOVAL-INTEGER-BETWEEN-UNIFY) (:RESTRICTION (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 200)) :REMOVAL-INTEGER-BETWEEN-CHECK))))) :EXPECTED-RESULT (QUOTE (((?X . 0)) ((?X . 1)))) :COMMENT "Ensures that we can solve a join-ordered without a restriction proof-spec in the focal position.")
  2425. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2426. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-WITH-FOCAL-RESTRICTION :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 1) (#$integerBetween 0 ?X 200)))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :PROOF-SPEC (:JOIN-ORDERED (:RESTRICTION (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 1)) :REMOVAL-INTEGER-BETWEEN-UNIFY)) (:RESTRICTION (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 200)) :REMOVAL-INTEGER-BETWEEN-CHECK))))) :EXPECTED-RESULT (QUOTE (((?X . 0)) ((?X . 1)))) :COMMENT "Ensures that we can solve a join-ordered with a restriction proof-spec in the focal position.")
  2427. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2428. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-WITH-FOCAL-RESTRICTION-OR :OWNER "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 1) (#$integerBetween 0 ?X 200)))) :PROPERTIES (QUOTE (:ADD-RESTRICTION-LAYER-OF-INDIRECTION? T :PROOF-SPEC (:JOIN-ORDERED (:RESTRICTION (:OR (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 1)) :REMOVAL-INTEGER-BETWEEN-UNIFY))) (:RESTRICTION (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 200)) :REMOVAL-INTEGER-BETWEEN-CHECK))))) :EXPECTED-RESULT (QUOTE (((?X . 0)) ((?X . 1)))) :COMMENT "Ensures that we can solve a join-ordered with a restriction proof-spec in the focal position
  2429.    that is a disjunctive proof spec.")
  2430. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2431. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-PROOF-SPEC :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 2 ?X 4) (#$integerBetween 0 ?X 10)))) :PROPERTIES (QUOTE (:BROWSABLE? T :PROOF-SPEC (:JOIN (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 10)) :REMOVAL-INTEGER-BETWEEN-UNIFY) (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 2 :ANYTHING 4)) :REMOVAL-INTEGER-BETWEEN-UNIFY)))) :EXPECTED-RESULT (QUOTE (((?X . 2)) ((?X . 3)) ((?X . 4)))) :COMMENT "Ensures that we can solve simple joins with a proof spec.")
  2432. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2433. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-OPEN-SPLIT-PROOF-SPEC :OWNER "rck" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$and (#$integerBetween 0 ?X 1) (#$isa #$Thing #$Collection)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:SPLIT (:REMOVAL (#$ist #$UniversalVocabularyMt (#$integerBetween 0 :ANYTHING 1)) :REMOVAL-INTEGER-BETWEEN-UNIFY) (:REMOVAL (#$ist #$UniversalVocabularyMt (#$isa #$Thing #$Collection)) :REMOVAL-ISA-COLLECTION-CHECK-POS)))) :EXPECTED-RESULT (QUOTE (((?X . 0)) ((?X . 1)))) :COMMENT "Ensures that we can solve a simple open split into two removal checks with a proof spec.")
  2434. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2435. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-PROOF-SPEC-1 :OWNER "rck" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$isa ?X #$Dog) (#$termStrings ?X "Muffet")))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN (:REMOVAL (#$ist #$InferencePSC (#$isa #$Muffet #$Dog)) :REMOVAL-ALL-INSTANCES) (:REMOVAL (#$ist #$InferencePSC (#$termStrings #$Muffet "Muffet")) (:OR :REMOVAL-GENLPREDS-LOOKUP-POS :REMOVAL-TERM-STRINGS-LOOKUP))))) :EXPECTED-RESULT (QUOTE (((?X . #$Muffet)))) :COMMENT "Ensures that we can solve a simple join with a proof spec.")
  2436. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2437. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-PROOF-SPEC-2 :OWNER "rck" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$isa ?X #$Dog) (#$termStrings ?X "Muffet")))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN (:REMOVAL (#$ist #$InferencePSC (#$isa #$Muffet #$Dog)) :REMOVAL-ALL-INSTANCES) (:REMOVAL (#$ist #$InferencePSC (#$termStrings #$Muffet "Muffet")) :REMOVAL-TERM-STRINGS-LOOKUP)))) :EXPECTED-RESULT (QUOTE (((?X . #$Muffet)))) :COMMENT "Ensures that we can solve a simple join with a more-specific proof-spec than that returned by from the original query.")
  2438. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2439. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-JOIN-PROOF-SPEC-3 :OWNER "rck" :KB :FULL :WORKING? NIL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$isa ?X #$Dog) (#$termStrings ?X "Muffet")))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN (:REMOVAL (#$ist #$InferencePSC (#$isa #$Muffet #$Dog)) :REMOVAL-ALL-INSTANCES) (:REMOVAL (#$ist #$InferencePSC (#$termStrings #$Muffet "Muffet")) :REMOVAL-GENLPREDS-LOOKUP-POS) (:REMOVAL (#$ist #$InferencePSC (#$isa #$Muffet #$FemaleAnimal)) :REMOVAL-ALL-INSTANCES)))) :EXPECTED-RESULT NIL :COMMENT "Ensures that we cannot solve a simple join with fewer conjuncts than the proof-spec.")
  2440. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2441. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-MULTI-LITERAL-FOCAL-1 :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X #$OrganismClassificationType) (#$genls #$Cat ?X) (#$genls ?X #$Mammal)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:CONJUNCTIVE-REMOVAL :REMOVAL-GENLS-BETWEEN (:RESTRICTION (:SPLIT (:REMOVAL (#$ist #$BaseKB (#$genls :ANYTHING :ANYTHING)) :REMOVAL-GENLS-BETWEEN) (:REMOVAL (#$ist #$BaseKB (#$genls :ANYTHING :ANYTHING)) :REMOVAL-GENLS-BETWEEN)))) (:RESTRICTION (:REMOVAL (#$ist #$BaseKB (#$isa :ANYTHING #$OrganismClassificationType)) :REMOVAL-ISA-COLLECTION-CHECK-POS))))) :EXPECTED-RESULT (QUOTE (((?X . #$Mammal)) ((?X . #$Eutheria)) ((?X . #$CarnivoreOrder)) ((?X . #$FelidaeFamily)) ((?X . #$FelisGenus)) ((?X . #$Cat)))) :COMMENT "Ensure that join-ordered with multi-literal focal succeeds with appropriate proof spec.")
  2442. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2443. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-MULTI-LITERAL-FOCAL-2 :OWNER "goolsbey" :KB :FULL :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?X #$OrganismClassificationType) (#$genls #$Cat ?X) (#$genls ?X #$Mammal)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:CONJUNCTIVE-REMOVAL :REMOVAL-GENLS-BETWEEN (:RESTRICTION (:SPLIT (:REMOVAL (#$ist #$BaseKB (#$genls :ANYTHING :ANYTHING)) :REMOVAL-GENLS-BETWEEN) (:REMOVAL (#$ist #$BaseKB (#$genls :ANYTHING :ANYTHING)) :REMOVAL-GENLS-BETWEEN) (:REMOVAL (#$ist #$BaseKB (#$genls :ANYTHING :ANYTHING)) :REMOVAL-GENLS-BETWEEN)))) (:RESTRICTION (:REMOVAL (#$ist #$BaseKB (#$isa :ANYTHING #$OrganismClassificationType)) :REMOVAL-ISA-COLLECTION-CHECK-POS))))) :EXPECTED-RESULT NIL :COMMENT "Ensure that join-ordered fails if there are too many conjuncts in the proof-spec for the split.")
  2444. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2445. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-SINGLE-LITERAL-FOCAL-1 :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$politiesBorderEachOther #$DistrictOfColumbia ?X) (#$isa ?X #$State-UnitedStates)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:REMOVAL (#$ist #$InferencePSC (#$politiesBorderEachOther #$DistrictOfColumbia :ANYTHING)) :REMOVAL-SYMMETRIC-LOOKUP-POS) (:RESTRICTION (:REMOVAL (#$ist #$InferencePSC (#$isa :ANYTHING #$State-UnitedStates)) :REMOVAL-ISA-COLLECTION-CHECK-POS))))) :EXPECTED-RESULT (QUOTE (((?X . #$Virginia-State)) ((?X . #$Maryland-State)))) :COMMENT "Ensure that join-ordered with single-literal focal problem works with an appropriate proof-spec.")
  2446. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2447. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-SINGLE-LITERAL-FOCAL-2 :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$politiesBorderEachOther #$DistrictOfColumbia ?X) (#$isa ?X #$State-UnitedStates)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:REMOVAL (#$ist #$InferencePSC (#$politiesBorderEachOther #$DistrictOfColumbia #$Virginia-State)) :REMOVAL-SYMMETRIC-LOOKUP-POS) (:RESTRICTION (:REMOVAL (#$ist #$InferencePSC (#$isa :ANYTHING #$State-UnitedStates)) :REMOVAL-ISA-COLLECTION-CHECK-POS))))) :EXPECTED-RESULT (QUOTE (((?X . #$Virginia-State)) ((?X . #$Maryland-State)))) :COMMENT "Ensure that join-ordered with single-literal focal problem returns answers from an overly-specific proof-spec.")
  2448. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2449. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-SINGLE-LITERAL-FOCAL-3 :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$politiesBorderEachOther #$DistrictOfColumbia :ANYTHING) (#$isa ?X #$State-UnitedStates)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:REMOVAL (#$ist #$InferencePSC (#$politiesBorderEachOther #$DistrictOfColumbia #$Pennsylvania-State)) :REMOVAL-SYMMETRIC-LOOKUP-POS) (:RESTRICTION (:REMOVAL (#$ist #$InferencePSC (#$isa :ANYTHING #$State-UnitedStates)) :REMOVAL-ISA-COLLECTION-CHECK-POS))))) :EXPECTED-RESULT NIL :COMMENT "Ensure that join-ordered with single-literal focal problem returns answers from an overly-specific proof-spec.")
  2450. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2451. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :JOIN-ORDERED-PROOF-SPEC-SINGLE-LITERAL-FOCAL-4 :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$InferencePSC (#$and (#$politiesBorderEachOther #$DistrictOfColumbia :ANYTHING) (#$isa ?X #$State-UnitedStates)))) :PROPERTIES (QUOTE (:PROOF-SPEC (:JOIN-ORDERED (:REMOVAL (#$ist #$InferencePSC (#$isa :ANYTHING #$State-UnitedStates)) :REMOVAL-ISA-COLLECTION-CHECK-POS) (:RESTRICTION (:REMOVAL (#$ist #$InferencePSC (#$politiesBorderEachOther #$DistrictOfColumbia :ANYTHING)) :REMOVAL-SYMMETRIC-LOOKUP-POS))))) :EXPECTED-RESULT NIL :COMMENT "Ensure that join-ordered with reversed focal and non-focal problems in proof-spec fails to return answers.")
  2452. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  2453. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :SIMPLE-UNION-PROOF-SPEC :OWNER "goolsbey" :KB :FULL :SENTENCE (QUOTE (#$ist #$WorldCompleteDualistGeographyMt (#$and (#$isa ?STATE #$State-UnitedStates) (#$or (#$politiesBorderEachOther ?STATE #$Canada) (#$politiesBorderEachOther ?STATE #$Mexico))))) :PROPERTIES (QUOTE (:PROOF-SPEC (:UNION (:JOIN-ORDERED (:REMOVAL (#$ist #$WorldCompleteDualistGeographyMt (#$politiesBorderEachOther :ANYTHING :ANYTHING)) (:OR :REMOVAL-LOOKUP-POS :REMOVAL-SYMMETRIC-LOOKUP-POS)) (:RESTRICTION (:REMOVAL (#$ist #$WorldCompleteDualistGeographyMt (#$isa :ANYTHING #$State-UnitedStates)) :REMOVAL-ISA-COLLECTION-CHECK-POS)))))) :EXPECTED-RESULT (QUOTE (((?STATE . #$Alaska-State)) ((?STATE . #$Arizona-State)) ((?STATE . #$California-State)) ((?STATE . #$Idaho-State)) ((?STATE . #$Maine-State)) ((?STATE . #$Michigan-State)) ((?STATE . #$Minnesota-State)) ((?STATE . #$Montana-State)) ((?STATE . #$NewHampshire-State)) ((?STATE . #$NewMexico-State)) ((?STATE . #$NewYork-State)) ((?STATE . #$NorthDakota-State)) ((?STATE . #$Pennsylvania-State)) ((?STATE . #$Texas-State)) ((?STATE . #$Vermont-State)) ((?STATE . #$Washington-State)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Ensure that we can handle :UNION proof specs properly.")
  2454. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  2455. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-WITH-PROOF-SPEC-RECONSIDER-SECOND-HALF-OF-SPLIT-1 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Collection) (#$forAll ?THING (?PRED ?THING)) (#$isa ?TERM #$Collection)) (#$and (?PRED ?TERM) (#$isa ?TERM #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL :PROOF-SPEC (:SPLIT (:REMOVAL (#$ist :ANYTHING (#$isa :ANYTHING #$Collection)) :REMOVAL-ISA-COLLECTION-CHECK-POS) (:TRANSFORMATION (#$ist :ANYTHING :ANYTHING) :TRANS-PREDICATE-POS :ANYTHING :NOTHING)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "We set aside the #$isa literal wrt removal, but once we use
  2456. transformation to prove (?PRED ?TERM), we need to reconsider it.")
  2457. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  2458. ;;; CYC(22): (DEFINE-INFERENCE-UNIT-TEST :TRANSFORMATION-WITH-PROOF-SPEC-RECONSIDER-SECOND-HALF-OF-SPLIT-2 :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$arg1Isa ?PRED #$Collection) (#$forAll ?THING (?PRED ?THING)) (#$isa ?TERM #$Collection)) (#$and (?PRED ?TERM) (#$isa ?TERM #$Collection))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1 :CONTINUABLE? NIL :PROOF-SPEC (:SPLIT (:REMOVAL (#$ist :ANYTHING (#$isa :ANYTHING #$Collection)) :REMOVAL-ISA-COLLECTION-CHECK-POS) (:TRANSFORMATION (#$ist :ANYTHING :ANYTHING) :TRANS-PREDICATE-NEG :ANYTHING :NOTHING)))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "See if transformation fails with the wrong transformation module in the proof-spec (should be :TRANS-PREDICATE-POS instead of TRANS-PREDICATE-NEG).")
  2459. ;;; Result(22)  <==== #<INFERENCE-UNIT-TEST 0>
  2460. ;;; CYC(23): (DEFINE-INFERENCE-UNIT-TEST :RESIDUAL-TRANSFORMATION-WITH-PROOF-SPEC-GENERATE-AND-TEST-WITH-TRANSFORMATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?TERM ?COL) (#$isa ?GENERATOR #$UnaryPredicate) (#$isa ?TESTER #$UnaryPredicate) (#$implies (#$elementOf ?N (#$TheSet 1 2)) (?GENERATOR ?N)) (#$backchainRequired ?TESTER) (#$implies (#$different ?N 1) (?TESTER ?N))) (#$and (?GENERATOR ?X) (?TESTER ?X))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 2 :ALLOWED-MODULES (:NOT :REMOVAL-ISA-DEFN-POS) :PROOF-SPEC (:OR (:RESIDUAL-TRANSFORMATION (#$ist :ANYTHING (:ANYTHING 2)) :TRANS-PREDICATE-POS :ANYTHING (:RESIDUAL-TRANSFORMATION (#$ist :ANYTHING (:ANYTHING 2)) :TRANS-PREDICATE-POS :ANYTHING (:JOIN-ORDERED (:REMOVAL (#$ist :ANYTHING (#$elementOf 2 (#$TheSet 1 2))) :REMOVAL-ELEMENTOF-UNIFY) (:RESTRICTION (:REMOVAL (#$ist :ANYTHING (#$different 2 1)) :REMOVAL-EVAL))))) (:JOIN-ORDERED (:TRANSFORMATION (#$ist :ANYTHING (:ANYTHING 2)) :TRANS-PREDICATE-POS :ANYTHING (:REMOVAL (#$ist :ANYTHING (#$elementOf 2 (#$TheSet 1 2))) :REMOVAL-ELEMENTOF-UNIFY)) (:TRANSFORMATION (#$ist :ANYTHING (:ANYTHING 2)) :TRANS-PREDICATE-POS :ANYTHING (:RESTRICTION (:REMOVAL (#$ist :ANYTHING (#$different 2 1)) :REMOVAL-EVAL))))))) :EXPECTED-RESULT (QUOTE (((?X . 2)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test residual transformation proof-specs.  Distilled from :backchain-forbidden-unless-arg-chosen-honored while testing residual transformation.")
  2461. ;;; Result(23)  <==== #<INFERENCE-UNIT-TEST 0>
  2462. ;;; CYC(24): :EOF
  2463. ;;; ... w:\cyc\top\tests\inference-proof-spec-test-cases.lisp loaded; SHA-1: 69ddc45e9d397f26c62f602987fac86aa61ad764
  2464. ;;; loading w:\cyc\top\tests\inference-abduction-test-cases.lisp ...
  2465. ;;; CYC(1): (DEFINE-INFERENCE-UNIT-TEST :UNKNOWN-SENTENCE-DEDUCTIVE-DURING-ABDUCTION :OWNER "goolsbey" :CREATOR "bfraser" :BUG 12332 :SENTENCE (QUOTE (#$ist #$BaseKB (#$unknownSentence (#$genls #$BinaryPredicate #$TernaryPredicate)))) :PROPERTIES (QUOTE (:ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that the unknownSentence removal modules do not use abductive tactics when doing their recursive asks.
  2466.    Without this behavior, #$unknownSentence is useless as a pragma during abductive inference.")
  2467. ;;; Result(1)  <==== #<INFERENCE-UNIT-TEST 0>
  2468. ;;; CYC(2): (DEFINE-INFERENCE-UNIT-TEST :ABDUCTION-WORKS-WITH-NEG-GAF-ON-PRED :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?T #$Thing) (#$isa ?T1 #$Thing) (#$isa ?T2 #$Thing) (?PRED ?T1 ?T1) (?PRED #$Thing ?T1) (#$not (?PRED ?T ?T2))) (?PRED ?T ?T1)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that the unknownSentence removal modules do not use abductive tactics when doing their recursive asks. Without this behavior, #$unknownSentence is useless as a pragma during abductive inference.")
  2469. ;;; Result(2)  <==== #<INFERENCE-UNIT-TEST 0>
  2470. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-CHECK :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?T #$Thing) (#$not (?PRED ?T))) (?PRED ?T)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2471. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2472. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-UNIFY :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?T #$Thing) (#$not (?PRED ?T))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2473. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2474. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-EXCLUSIVE :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?T #$Thing) (#$implies (?PRED ?X) (?PRED2 ?X)) (#$not (?PRED ?T))) (?PRED2 ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T :TRANSFORMATION-ALLOWED? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2475. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2476. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-CHECK-2 :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$genlPreds ?PRED ?PRED2) (#$isa ?T #$Thing) (#$not (?PRED2 ?T))) (?PRED ?T)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2477. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2478. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-UNIFY-2 :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$genlPreds ?PRED ?PRED2) (#$isa ?T #$Thing) (#$not (?PRED2 ?T))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2479. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2480. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-FALSE-ASENT-EXCLUSIVE-2 :OWNER "goolsbey" :BUG 16583 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED2 #$UnaryPredicate) (#$isa ?PRED3 #$UnaryPredicate) (#$genlPreds ?PRED ?PRED3) (#$isa ?T #$Thing) (#$implies (?PRED ?X) (?PRED2 ?X)) (#$not (?PRED3 ?T))) (?PRED2 ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T :TRANSFORMATION-ALLOWED? T :MAX-TRANSFORMATION-DEPTH 1)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce a false asent")
  2481. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2482. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-NEGATION-OF-TRUE-ASENT-CHECK :OWNER "zelal" :BUG 17964 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?T #$Thing) (?PRED ?T)) (#$not (?PRED ?T))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce the negation of a true asent")
  2483. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2484. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :DONT-ABDUCE-NEGATION-OF-TRUE-ASENT-CHECK-2 :OWNER "zelal" :BUG 17964 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?GENL-PRED #$UnaryPredicate) (#$genlPreds ?PRED ?GENL-PRED) (#$isa ?T #$Thing) (?PRED ?T)) (#$not (?GENL-PRED ?T))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :COMMENT "Ensure that the abduction modules do not abduce the negation of a true asent")
  2485. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2486. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-PREDICATE :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED #$NonAbduciblePredicate)) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$NonAbduciblePredicate is honored during abduction.")
  2487. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2488. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-RELATION :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?PRED #$NonAbducibleRelation)) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$NonAbducibleRelation is honored during abduction.")
  2489. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2490. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-COLLECTION :OWNER "zelal" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?COLL #$NonAbducibleCollection) (#$isa ?INST ?COLL)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$NonAbducibleCollection is honored during abduction.")
  2491. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2492. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-COMPLETE-EXTENT-ENUMERABLE-FOR-ARG :OWNER "zelal" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$completeExtentEnumerableForArg ?PRED 1)) (?PRED ?X ?Y)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$completeExtentEnumerableForArg is honored during abduction.")
  2493. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2494. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-FOR-ARG :OWNER "zelal" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$notAbducibleForArg ?PRED 1)) (?PRED ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$notAbducibleForArg is honored during abduction.")
  2495. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2496. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-WRT-VALUE-IN-ARG :OWNER "zelal" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?T #$Thing) (#$notAbducibleWRTValueInArg ?PRED ?T 1)) (?PRED ?T ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$notAbducibleWRTValueInArg is honored during abduction.")
  2497. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2498. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :NON-ABDUCIBLE-WRT-TYPE-IN-ARG :OWNER "zelal" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?TYPE #$Collection) (#$notAbducibleWRTTypeInArg ?PRED ?TYPE 1) (#$isa ?T ?TYPE)) (?PRED ?T ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS :ABDUCTION-ALLOWED? T)) :EXPECTED-RESULT NIL :KB :FULL :COMMENT "Verify #$notAbducibleWRTTypeInArg is honored during abduction.")
  2499. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2500. ;;; CYC(18): :EOF
  2501. ;;; ... w:\cyc\top\tests\inference-abduction-test-cases.lisp loaded; SHA-1: 40e8946bec1045e9789838289bb38600ba2a2a4e
  2502. ;;; loading w:\cyc\top\tests\czer-unit-test-cases.lisp ...
  2503. ;;; CYC(1): (IN-PACKAGE "CYC")
  2504. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2505. ;;; CYC(2): (CVS-ID "$Id: czer-unit-test-cases.lisp 129153 2009-11-09 23:02:22Z pace $")
  2506. ;;; Result(2)  <==== CL:NIL
  2507. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :TAUTOLOGY :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$or ?PROP (#$not ?PROP)))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Test that tautologies are handled correctly")
  2508. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2509. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :CONTRADICTION :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$LogicalTruthMt (#$and ?PROP (#$not ?PROP)))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :CONTRADICTION :COMMENT "Test that contradictions are handled correctly")
  2510. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2511. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-1 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$CyclistDefinitionalMt NIL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 0)))) :COMMENT "Not allowed to use genlMts, can't find anything.")
  2512. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2513. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-2 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$CyclistDefinitionalMt T)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 2)))) :COMMENT "Allowed to use genlMts, can see them both from the specMt.")
  2514. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2515. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-3 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$BaseKB T)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 2)))) :COMMENT "Allowed to use genlMts, can see them both from the lower mt.")
  2516. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2517. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-4 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$BaseKB NIL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 1)))) :COMMENT "Not allowed to use genlMts, only gets the explicitly asserted one.")
  2518. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2519. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-5 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$EverythingPSC NIL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 0)))) :COMMENT "Nothing is directly asserted in #$EverythingPSC; genlMts must be used for this to find anything.")
  2520. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2521. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-6 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$EverythingPSC T)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 2)))) :COMMENT "With genlMts enabled, #$EverythingPSC can see everything.")
  2522. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2523. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-7 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$InferencePSC NIL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 0)))) :COMMENT "Nothing is directly asserted in #$InferencePSC; genlMts must be used for this to find anything.")
  2524. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2525. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-ASSERTIONS-IN-MT-8 :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$ist #$UniversalVocabularyMt (?PRED "a")) (#$ist #$BaseKB (?PRED "a"))) (#$evaluate ?NUMBER-OF-ASSERTIONS (#$EvaluateSubLFn (#$SubLQuoteFn (LENGTH (SENTENCE-ASSERTIONS-IN-MT (QUOTE (?PRED "a")) #$InferencePSC T)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?NUMBER-OF-ASSERTIONS . 2)))) :COMMENT "With genlMts enabled, #$InferencePSC can see everything.")
  2526. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2527. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :KAPPA-SIMPLIFY-UNARY :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate)) (#$trueSubL (#$SubLQuoteFn (EQUAL (CANONICALIZE-CYCL (QUOTE ((#$Kappa (?OBJ) (?PRED ?OBJ "b")) "a"))) (QUOTE (((NIL ((?PRED "a" "b"))) NIL))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a unary #$Kappa expression can be simplified by substituting the
  2528.    single argument of the kappa expression into the arg2 of #$Kappa.")
  2529. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2530. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :KAPPA-QUERY :OWNER "jantos" :CREATOR "goolsbey" :BUG 9512 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB ((#$Kappa (?OBJ) (#$equals ?OBJ 212)) 212))) :PROPERTIES (QUOTE (:ALLOWED-MODULES :REMOVAL-UNIFY)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a #$Kappa query of an asent is simplified to just the asent.")
  2531. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2532. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :ILL-FORMED-KAPPA-WRT-ARG :OWNER "jantos" :CREATOR "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB ((#$Kappa (?X ?Y) (#$isa ?X ?Y)) (#$Microtheory #$Collection)))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "Test that the args of a #$Kappa literal are syntactically verified.")
  2533. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2534. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :ILL-FORMED-KAPPA-WRT-ARITY :OWNER "jantos" :CREATOR "goolsbey" :BUG 14459 :SENTENCE (QUOTE (#$ist #$BaseKB ((#$Kappa (?X ?Y) (#$isa ?X ?Y)) #$Microtheory))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "Test that the arity of a #$Kappa literal is properly enforced.")
  2535. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2536. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-VARIABLES-VARIABLE-MT :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$trueSubL (#$SubLQuoteFn (SETS-EQUAL? (SENTENCE-VARIABLES (QUOTE (#$ist ?MT ?PROP))) (QUOTE (?PROP ?MT)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that @xref sentence-variables looks in the mt as well as the designated
  2537.    sentence of an mt-designating literal.")
  2538. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2539. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-VARIABLES-OPEN-MT :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$UnaryFunction) (#$resultIsa ?FUNC #$Microtheory)) (#$trueSubL (#$SubLQuoteFn (SETS-EQUAL? (SENTENCE-VARIABLES (QUOTE (#$ist (#$MtSpace ?MT (?FUNC ?INTERVAL)) ?PROP))) (QUOTE (?PROP ?MT ?INTERVAL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that @xref sentence-variables looks in the mt as well as the designated
  2540.    sentence of an mt-designating literal.")
  2541. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2542. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-FREE-VARIABLES-VARIABLE-MT :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$trueSubL (#$SubLQuoteFn (SETS-EQUAL? (SENTENCE-FREE-VARIABLES (QUOTE (#$ist ?MT ?PROP))) (QUOTE (?PROP ?MT)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that @xref sentence-free-variables looks in the mt as well as the designated
  2543.    sentence of an mt-designating literal.")
  2544. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  2545. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-FREE-VARIABLES-OPEN-MT :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$UnaryFunction) (#$resultIsa ?FUNC #$Microtheory)) (#$trueSubL (#$SubLQuoteFn (SETS-EQUAL? (SENTENCE-FREE-VARIABLES (QUOTE (#$ist (#$MtSpace ?MT (?FUNC ?INTERVAL)) ?PROP))) (QUOTE (?PROP ?MT ?INTERVAL)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that @xref sentence-free-variables looks in the mt as well as the designated
  2546.    sentence of an mt-designating literal.")
  2547. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  2548. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :SENTENCE-FREE-SEQUENCE-VARIABLES-OPEN-MT :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$trueSubL (#$SubLQuoteFn (SETS-EQUAL? (SENTENCE-FREE-SEQUENCE-VARIABLES (QUOTE (#$ist (#$MtSpace ?MT . ?OTHER-DIMS) ?PROP))) (QUOTE (?OTHER-DIMS)))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that @xref sentence-free-sequence-variables looks in the mt as well as the designated
  2549.    sentence of an mt-designating literal.")
  2550. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  2551. ;;; CYC(22): (DEFINE-INFERENCE-UNIT-TEST :CYC-ASSERT-WITH-REIFIABLE-MONAD-MT :OWNER "jantos" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$resultIsa ?FUNC #$Microtheory) (#$isa ?COL #$Collection) (#$genls ?COL #$Individual) (#$isa ?OBJ #$Individual)) (#$trueSubL (#$ExpandSubLFn (?FUNC ?OBJ ?COL) (CYC-ASSERT (QUOTE (#$isa ?OBJ ?COL)) (QUOTE (?FUNC 49)))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (FIND-NART (QUOTE (?FUNC 49)))))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that canonicalize-assert-mt causes the
  2552.    reifiable monad mt (?FUNC 49) to become reified.")
  2553. ;;; Result(22)  <==== #<INFERENCE-UNIT-TEST 0>
  2554. ;;; CYC(23): (DEFINE-INFERENCE-UNIT-TEST :DONT-REORDER-COMMUTATIVE-ARGS-OF-NESTED-SENTENCES :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$arg1QuotedIsa ?PRED #$CycLSentence)) (#$ist #$UniversalVocabularyMt (#$canonicalizerDirectiveForArg ?PRED 1 #$DontReOrderCommutativeTerms))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (?PRED (#$and (#$not (#$isa "f" #$Collection)) (#$not (#$isa "u" #$Predicate)) (#$not (#$isa "b" #$Microtheory)) (#$not (#$isa "a" #$Function-Denotational)) (#$not (#$isa "r" #$January)))) (#$assertedSentence (?PRED (#$and (#$not (#$isa ?F #$Collection)) (#$not (#$isa ?U #$Predicate)) (#$not (#$isa ?B ?MT)) (#$not (#$isa ?A #$Function-Denotational)) (#$not (#$isa ?R #$January))))))) :PROPERTIES (:CONDITIONAL-SENTENCE? T) :EXPECTED-RESULT (((?F . "f") (?U . "u") (?B . "b") (?A . "a") (?R . "r") (?MT . #$Microtheory)))))) :COMMENT "Test that the #$DontReOrderCommutativeTerms canonicalizer directive is
  2555. respected for nested sentences.")
  2556. ;;; Result(23)  <==== #<INFERENCE-UNIT-TEST 0>
  2557. ;;; CYC(24): (DEFINE-INFERENCE-UNIT-TEST :DONT-REORDER-COMMUTATIVE-ARGS-OF-NESTED-SENTENCES-REMINDER :OWNER "jantos" :CREATOR "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$ist #$UniversalVocabularyMt (#$isa ?PRED #$UnaryPredicate)) (#$ist #$UniversalVocabularyMt (#$arg1QuotedIsa ?PRED #$CycLSentence))) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$UniversalVocabularyMt (#$implies (?PRED (#$and (#$not (#$isa "f" #$Collection)) (#$not (#$isa "u" #$Predicate)) (#$not (#$isa "b" #$Microtheory)) (#$not (#$isa "a" #$Function-Denotational)) (#$not (#$isa "r" #$January)))) (#$assertedSentence (?PRED (#$and (#$not (#$isa ?F #$Collection)) (#$not (#$isa ?U #$Predicate)) (#$not (#$isa ?B ?MT)) (#$not (#$isa ?A #$Function-Denotational)) (#$not (#$isa ?R #$January))))))) :PROPERTIES (:CONDITIONAL-SENTENCE? T) :EXPECTED-RESULT NIL))) :COMMENT "This test is exactly like :dont-reorder-commutative-args-of-nested-sentences-reminder
  2558. except it lacks the canonicalizer directive, and ought to yield no answers.  When this
  2559. test fails, it's a reminder to change the :dont-reorder-commutative-args-of-nested-sentences
  2560. unit test to not depend on the removal module for #$assertedSentence not being able to handle
  2561. commutativity.")
  2562. ;;; Result(24)  <==== #<INFERENCE-UNIT-TEST 0>
  2563. ;;; CYC(25): (DEFINE-INFERENCE-UNIT-TEST :WFF-DOESNT-CHOKE-ON-SMALL-DISTRIBUTING-SENTENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :COMMENT "Test that the wff checker doesn't choke when given this small distributing sentence
  2564. of 7 conjuncts.")
  2565. ;;; Result(25)  <==== #<INFERENCE-UNIT-TEST 0>
  2566. ;;; CYC(26): (DEFINE-INFERENCE-UNIT-TEST :WFF-DOESNT-CHOKE-ON-MEDIUM-DISTRIBUTING-SENTENCE :OWNER "pace" :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :COMMENT "Test that the wff checker doesn't choke when given this medium-sized, very distributing sentence
  2567. of 17 conjuncts.")
  2568. ;;; Result(26)  <==== #<INFERENCE-UNIT-TEST 0>
  2569. ;;; CYC(27): (DEFINE-INFERENCE-UNIT-TEST :WFF-DOESNT-CHOKE-ON-LARGE-DISTRIBUTING-SENTENCE :OWNER "pace" :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT-TEST (QUOTE TRUE) :COMMENT "Test that the wff checker doesn't choke when given this large, massively distributing sentence
  2570. of 48 conjuncts.")
  2571. ;;; Result(27)  <==== #<INFERENCE-UNIT-TEST 0>
  2572. ;;; CYC(28): (DEFINE-INFERENCE-UNIT-TEST :WFF-SMALL-DISTRIBUTING-SENTENCE :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the wff checker does the right thing when given this small distributing sentence
  2573. of 7 conjuncts.")
  2574. ;;; Result(28)  <==== #<INFERENCE-UNIT-TEST 0>
  2575. ;;; CYC(29): (DEFINE-INFERENCE-UNIT-TEST :WFF-MEDIUM-DISTRIBUTING-SENTENCE :OWNER "pace" :WORKING? NIL :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the wff checker does the right thing when given this medium-sized, very distributing sentence
  2576. of 17 conjuncts.")
  2577. ;;; Result(29)  <==== #<INFERENCE-UNIT-TEST 0>
  2578. ;;; CYC(30): (DEFINE-INFERENCE-UNIT-TEST :WFF-LARGE-DISTRIBUTING-SENTENCE :OWNER "pace" :WORKING? NIL :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (EL-WFF? (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the wff checker does the right thing when given this large, massively distributing sentence
  2579. of 48 conjuncts.")
  2580. ;;; Result(30)  <==== #<INFERENCE-UNIT-TEST 0>
  2581. ;;; CYC(31): (DEFINE-INFERENCE-UNIT-TEST :WFF-VIOLATION-BAD-EXPONENTIAL-DISJUNCTION :OWNER "pace" :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (TREE-FIND :BAD-EXPONENTIAL-DISJUNCTION (WHY-NOT-WFF (QUOTE (#$implies (#$and (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$or (?PRED-B ?LIST ?NUM) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$and (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the wff checker returns a :bad-exponential-disjunction violation on this sentence.")
  2582. ;;; Result(31)  <==== #<INFERENCE-UNIT-TEST 0>
  2583. ;;; CYC(32): (DEFINE-INFERENCE-UNIT-TEST :WFF-VIOLATION-BAD-EXPONENTIAL-CONJUNCTION :OWNER "pace" :BUG 10890 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED-A #$BinaryPredicate) (#$isa ?PRED-B #$BinaryPredicate) (#$isa ?PRED-C #$BinaryPredicate) (#$isa ?COL-A #$Collection) (#$isa ?INTERVAL-MAX-FN #$UnaryFunction) (#$isa ?INTERVAL-MIN-FN #$UnaryFunction) (#$isa ?FN-A #$BinaryFunction) (#$isa ?FN-B #$BinaryFunction) (#$isa ?SKF-1 #$QuaternaryFunction) (#$isa ?SKF-2 #$QuaternaryFunction)) (#$trueSubL (#$SubLQuoteFn (TREE-FIND :BAD-EXPONENTIAL-CONJUNCTION (WHY-NOT-QUERY-OK (QUOTE (#$implies (#$or (?PRED-A ?LIST ?TYPE) (#$isa ?LIST ?COL-A)) (#$and (?PRED-B ?LIST ?NUM) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM)) (#$or (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE) (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-B ?LIST ?NUM) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-B ?LIST ?NUM) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)) (#$or (#$isa (?SKF-1 ?LIST ?NUM ?TYPE (?INTERVAL-MAX-FN (?FN-A ?NUM 1))) ?TYPE) (?PRED-C (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?LIST) (#$isa (?SKF-2 ?LIST ?NUM ?TYPE (?INTERVAL-MIN-FN (?FN-B ?NUM 1))) ?TYPE)))))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :DISJUNCTION-FREE-EL-VARS-POLICY :COMPUTE-INTERSECTION)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the wff checker returns a :bad-exponential-conjunction violation on this sentence.")
  2584. ;;; Result(32)  <==== #<INFERENCE-UNIT-TEST 0>
  2585. ;;; CYC(33): (DEFINE-INFERENCE-UNIT-TEST :ASSERT-BIG-DISJUNCTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$or (#$different 1 2 3 4 5 6 7 8 9 10) (#$different 1 2 3 4 5 6 7 8 9 11) (#$different 1 2 3 4 5 6 7 8 9 12) (#$different 1 2 3 4 5 6 7 8 9 13) (#$different 1 2 3 4 5 6 7 8 9 14) (#$different 1 2 3 4 5 6 7 8 9 15)) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the antecedent can be hypothesized without erroneously triggering a
  2586. :bad-exponential-disjunction error.")
  2587. ;;; Result(33)  <==== #<INFERENCE-UNIT-TEST 0>
  2588. ;;; CYC(34): (DEFINE-INFERENCE-UNIT-TEST :QUERY-BIG-CONJUNCTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?X #$Thing) (#$and (#$different 1 2 3 4 5 6 7 8 9 10) (#$different 1 2 3 4 5 6 7 8 9 11) (#$different 1 2 3 4 5 6 7 8 9 12) (#$different 1 2 3 4 5 6 7 8 9 13) (#$different 1 2 3 4 5 6 7 8 9 14) (#$different 1 2 3 4 5 6 7 8 9 15))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that the consequent can be queried without erroneously triggering a
  2589. :bad-exponential-conjunction error.")
  2590. ;;; Result(34)  <==== #<INFERENCE-UNIT-TEST 0>
  2591. ;;; CYC(35): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-ASSERTION-EQUAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?MT #$Microtheory) (#$ist ?MT (?PRED "a"))) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (QUOTE (#$ist ?MT (?PRED "a"))) (FIND-GAF (QUOTE (?PRED "a")) ?MT))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that equals-el? equates an assertion with its corresponding #$ist EL sentence.")
  2592. ;;; Result(35)  <==== #<INFERENCE-UNIT-TEST 0>
  2593. ;;; CYC(36): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-ASSERTION-NOT-EQUAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?MT #$Microtheory) (#$ist ?MT (?PRED "a"))) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (QUOTE (?PRED "a")) (FIND-GAF-ANY-MT (QUOTE (?PRED "a"))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that equals-el? fails to equate assertions with non-mt-specific EL sentences.")
  2594. ;;; Result(36)  <==== #<INFERENCE-UNIT-TEST 0>
  2595. ;;; CYC(37): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-NART-EQUAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$comment (?FUNC "a") "think of this nart")) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (FIND-NART (QUOTE (?FUNC "a"))) (QUOTE (?FUNC "a")))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that equals-el? equates a nart with its EL formula.")
  2596. ;;; Result(37)  <==== #<INFERENCE-UNIT-TEST 0>
  2597. ;;; CYC(38): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-NART-NOT-EQUAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$comment (?FUNC "a") "think of this nart")) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (FIND-NART (QUOTE (?FUNC "a"))) (QUOTE (?FUNC "b")))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that equals-el? fails to equate a nart with something that's not its EL formula.")
  2598. ;;; Result(38)  <==== #<INFERENCE-UNIT-TEST 0>
  2599. ;;; CYC(39): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-EQUAL-VIA-SYMMETRY :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$CommutativeRelation)) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (QUOTE (?PRED "a" "b")) (QUOTE (?PRED "b" "a")))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that equals-el? equates two EL sentences that have the same canonical form.")
  2600. ;;; Result(39)  <==== #<INFERENCE-UNIT-TEST 0>
  2601. ;;; CYC(40): (DEFINE-INFERENCE-UNIT-TEST :EQUALS-EL-NOT-EQUAL-VIA-SYMMETRY :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$isa ?PRED #$BinaryPredicate) (#$trueSubL (#$SubLQuoteFn (EQUALS-EL? (QUOTE (?PRED "a" "b")) (QUOTE (?PRED "b" "a")))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :COMMENT "Test that equals-el? fails to equates two EL sentences that do not have the same canonical form.")
  2602. ;;; Result(40)  <==== #<INFERENCE-UNIT-TEST 0>
  2603. ;;; CYC(41): (DEFINE-INFERENCE-UNIT-TEST :CANONICALIZE-REIFIABLE-NAUT-INTO-NART :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$ReifiableFunction) (#$isa ?FUNC #$UnaryFunction) (#$isa ?PRED #$UnaryPredicate) (?PRED (?FUNC "a"))) (#$thereExists ?NART (#$natFunction ?NART ?FUNC))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :ANSWER-LANGUAGE :HL)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that a reifiable function actually results in reification of a NART.")
  2604. ;;; Result(41)  <==== #<INFERENCE-UNIT-TEST 0>
  2605. ;;; CYC(42): (DEFINE-INFERENCE-UNIT-TEST :DECONTEXTUALIZE-TO-A-HIGHER-MT :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$BaseKB) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT) (#$decontextualizedPredicate ?PRED) (#$predicateConventionMt ?PRED ?GENL-MT) (#$ist ?SPEC-MT (?PRED 212))) (#$ist-Asserted ?GENL-MT (?PRED 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that decontextualization will raise to a higher mt.")
  2606. ;;; Result(42)  <==== #<INFERENCE-UNIT-TEST 0>
  2607. ;;; CYC(43): (DEFINE-INFERENCE-UNIT-TEST :DECONTEXTUALIZE-TO-A-SIBLING-MT :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?CONVENTION-MT #$Microtheory) (#$genlMt ?CONVENTION-MT #$BaseKB) (#$isa ?SIBLING-MT #$Microtheory) (#$genlMt ?SIBLING-MT #$BaseKB) (#$decontextualizedPredicate ?PRED) (#$predicateConventionMt ?PRED ?CONVENTION-MT) (#$ist ?SIBLING-MT (?PRED 212))) (#$ist-Asserted ?CONVENTION-MT (?PRED 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that decontextualization will go to a sibling mt.")
  2608. ;;; Result(43)  <==== #<INFERENCE-UNIT-TEST 0>
  2609. ;;; CYC(44): (DEFINE-INFERENCE-UNIT-TEST :DONT-DECONTEXTUALIZE-TO-A-LOWER-MT :OWNER "pace" :BUG 11354 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$BaseKB) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT) (#$decontextualizedPredicate ?PRED) (#$predicateConventionMt ?PRED ?SPEC-MT) (#$ist ?GENL-MT (?PRED 212))) (#$ist-Asserted ?GENL-MT (?PRED 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that decontextualization will not drop to a lower mt.")
  2610. ;;; Result(44)  <==== #<INFERENCE-UNIT-TEST 0>
  2611. ;;; CYC(45): (DEFINE-INFERENCE-UNIT-TEST :CONVENTION-MT-WINS-IN-MT-LOOPS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (#$isa ?LOOP-MT #$Microtheory) (#$genlMt ?LOOP-MT #$BaseKB) (#$isa ?CONVENTION-MT #$Microtheory) (#$genlMt ?CONVENTION-MT ?LOOP-MT) (#$genlMt ?LOOP-MT ?CONVENTION-MT) (#$decontextualizedPredicate ?PRED) (#$predicateConventionMt ?PRED ?CONVENTION-MT) (#$ist ?LOOP-MT (?PRED 212))) (#$ist-Asserted ?CONVENTION-MT (?PRED 212))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that ensures that decontextualization will prefer the convention mt
  2612. when in an mt loop.")
  2613. ;;; Result(45)  <==== #<INFERENCE-UNIT-TEST 0>
  2614. ;;; CYC(46): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-ALLOWED :OWNER "goolsbey" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$arity ?RELN 0) (#$arity ?RELN ?WHAT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?WHAT . 0)))) :COMMENT "Verify that an arity of 0 is allowable at all.")
  2615. ;;; Result(46)  <==== #<INFERENCE-UNIT-TEST 0>
  2616. ;;; CYC(47): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-UNREIFIABLE-FUNCTION :OWNER "goolsbey" :BUG 11498 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$FixedArityRelation) (#$isa ?FUNC #$UnreifiableFunction) (#$arity ?FUNC 0) (#$isa ?PRED #$UnaryFunction) (?PRED (?FUNC))) (#$thereExists ?WHAT (?PRED ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity unreifiable functions are supported.")
  2617. ;;; Result(47)  <==== #<INFERENCE-UNIT-TEST 0>
  2618. ;;; CYC(48): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-REIFIABLE-FUNCTION :OWNER "goolsbey" :BUG 11498 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$FixedArityRelation) (#$isa ?FUNC #$ReifiableFunction) (#$arity ?FUNC 0) (#$isa ?PRED #$UnaryFunction) (?PRED (?FUNC))) (#$thereExists ?NART (#$natFunction ?NART ?FUNC))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity reifiable functions are supported.")
  2619. ;;; Result(48)  <==== #<INFERENCE-UNIT-TEST 0>
  2620. ;;; CYC(49): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-EVALUATABLE-FUNCTION-EVALUATABLE-EXPANSION :OWNER "goolsbey" :BUG 11498 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$FixedArityRelation) (#$isa ?FUNC #$EvaluatableFunction) (#$arity ?FUNC 0) (#$expansion ?FUNC (#$TimesFn 4 53))) (#$evaluate 212 (?FUNC))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity evaluatable functions with evaluatable expansions are supported.")
  2621. ;;; Result(49)  <==== #<INFERENCE-UNIT-TEST 0>
  2622. ;;; CYC(50): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-EVALUATABLE-FUNCTION-ATOMIC-EXPANSION :OWNER "goolsbey" :BUG 11498 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?FUNC #$FixedArityRelation) (#$isa ?FUNC #$EvaluatableFunction) (#$arity ?FUNC 0) (#$expansion ?FUNC 212)) (#$evaluate 212 (?FUNC))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity evaluatable functions with atomic expansions are supported.")
  2623. ;;; Result(50)  <==== #<INFERENCE-UNIT-TEST 0>
  2624. ;;; CYC(51): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-PREDICATE :OWNER "goolsbey" :BUG 11498 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$FixedArityRelation) (#$isa ?PRED #$Predicate) (#$arity ?PRED 0) (?PRED)) (#$assertedSentence (?PRED))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity predicates are supported.")
  2625. ;;; Result(51)  <==== #<INFERENCE-UNIT-TEST 0>
  2626. ;;; CYC(52): (DEFINE-INFERENCE-UNIT-TEST :0-ARITY-EVALUATABLE-PREDICATE :OWNER "goolsbey" :BUG 11498 :WORKING? NIL :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$FixedArityRelation) (#$isa ?PRED #$EvaluatablePredicate) (#$arity ?PRED 0) (#$expansion ?PRED (#$different 1 2))) (?PRED)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Verify that 0-arity evaluatable predicates are supported.")
  2627. ;;; Result(52)  <==== #<INFERENCE-UNIT-TEST 0>
  2628. ;;; CYC(53): (DEFINE-INFERENCE-UNIT-TEST :QUOTED-VARIABLE-CAPTURE :OWNER "goolsbey" :BUG 12012 :SENTENCE (QUOTE (#$equalSymbols (#$SubLQuoteFn ?X) ?X)) :EXPECTED-RESULT (QUOTE (((?X #$SubLQuoteFn ?X)))) :COMMENT "Ensure that the CZER does not treat the quoted and unquoted ?X variables the same.")
  2629. ;;; Result(53)  <==== #<INFERENCE-UNIT-TEST 0>
  2630. ;;; CYC(54): (DEFINE-INFERENCE-UNIT-TEST :EXPANDSUBLFN-VARIABLE-RENAMING :OWNER "jantos" :BUG 5126 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$thereExists ?ITEM (#$and (#$elementOf ?ITEM (#$TheSet 212 "212")) (#$trueSubL (#$ExpandSubLFn (?ITEM) (STRINGP ?ITEM))))))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Ensure that the CZER properly renames the variables in the arg1 and arg2 of #$ExpandSubLFn.  Only those variables in the arg1 of #$ExpandSubLFn should be renamed in the arg2 of #$ExpandSubLFn.")
  2631. ;;; Result(54)  <==== #<INFERENCE-UNIT-TEST 0>
  2632. ;;; CYC(55): (DEFINE-INFERENCE-UNIT-TEST :UNARY-NEGATION-PREDS :OWNER "jantos" :CREATOR "goolsbey" :BUG 12708 :WORKING? NIL :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?NOT-P #$UnaryPredicate) (#$negationPreds ?P ?NOT-P) (?P "a") (?NOT-P "a")) #$False))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Should be rejected due to a unary negationPreds between ?P and ?NOT-P.")
  2633. ;;; Result(55)  <==== #<INFERENCE-UNIT-TEST 0>
  2634. ;;; CYC(56): (DEFINE-INFERENCE-UNIT-TEST :BINARY-NEGATION-PREDS :OWNER "jantos" :CREATOR "goolsbey" :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?NOT-P #$BinaryPredicate) (#$negationPreds ?P ?NOT-P) (?P "a" "b") (?NOT-P "a" "b")) #$False))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Should be rejected due to a binary negationPreds between ?P and ?NOT-P.")
  2635. ;;; Result(56)  <==== #<INFERENCE-UNIT-TEST 0>
  2636. ;;; CYC(57): (DEFINE-INFERENCE-UNIT-TEST :TERNARY-NEGATION-PREDS :OWNER "jantos" :CREATOR "goolsbey" :WORKING? NIL :BUG 12708 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$TernaryPredicate) (#$isa ?NOT-P #$TernaryPredicate) (#$negationPreds ?P ?NOT-P) (?P "a" "b" "c") (?NOT-P "a" "b" "c")) #$False))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Should be rejected due to a ternary negationPreds between ?P and ?NOT-P.")
  2637. ;;; Result(57)  <==== #<INFERENCE-UNIT-TEST 0>
  2638. ;;; CYC(58): (DEFINE-INFERENCE-UNIT-TEST :IST-DISTRIBUTES-OVER-AND :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$UnaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$isa ?R #$UnaryPredicate) (#$isa ?S #$UnaryPredicate) (#$ist #$BookkeepingMt (?P "a")) (#$ist #$BookkeepingMt (?Q "a")) (#$ist #$UniversalVocabularyMt (?R "a")) (#$ist #$UniversalVocabularyMt (?S "a"))) (#$and (#$ist #$BookkeepingMt (#$and (?P "a") (?Q "a"))) (#$ist #$UniversalVocabularyMt (#$and (?R "a") (?S "a"))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that #$ist distributes over #$and in the query")
  2639. ;;; Result(58)  <==== #<INFERENCE-UNIT-TEST 0>
  2640. ;;; CYC(59): (DEFINE-INFERENCE-UNIT-TEST :NOT-AN-IMPLICATION :OWNER "pace" :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$isa ?P #$UnaryPredicate) (?P "a") (?P ?X)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :ILL-FORMED :COMMENT "Test that the inference engine doesn't crash on malformed implications")
  2641. ;;; Result(59)  <==== #<INFERENCE-UNIT-TEST 0>
  2642. ;;; CYC(60): (DEFINE-INFERENCE-UNIT-TEST :GAF-WITH-CLOSED-EVALUATABLE-ARGUMENT :OWNER "pace" :CREATOR "goolsbey" :WORKING? NIL :BUG 14984 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$UnaryPredicate) (?PRED (#$PlusFn 1 2))) (?PRED ?WHAT)))) :PROPERTIES (QUOTE (:CONTINUABLE? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST :FOLLOWUPS (QUOTE ((:SENTENCE :CONTINUE :PROPERTIES (:MAX-TRANSFORMATION-DEPTH 1) :EXPECTED-RESULT (((?WHAT . 3))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL))) :COMMENT "(?PRED (#$PlusFn 1 2)) should be canonicalized into a rule, not a GAF.")
  2643. ;;; Result(60)  <==== #<INFERENCE-UNIT-TEST 0>
  2644. ;;; CYC(61): (DEFINE-INFERENCE-UNIT-TEST :CANONICALIZE-ATEMPORAL-ANYTIME-PSC-HLMT :OWNER "pace" :BUG 18934 :KB :FULL :SENTENCE (QUOTE (#$ist (#$MtSpace #$BaseKB #$AnytimePSC) (#$isa #$Thing #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :COMMENT "Test that we can properly canonicalize the HLMT (#$MtSpace #$BaseKB #$AnytimePSC)")
  2645. ;;; Result(61)  <==== #<INFERENCE-UNIT-TEST 0>
  2646. ;;; CYC(62): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-RULE-CONCLUDING-TRUE :OWNER "pace" :CREATOR "pace" :BUG 18909 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$implies (#$equalSymbols ?PROP #$True) (#$ist #$BaseKB ?PROP)) (#$assertionDirection (#$implies (#$equalSymbols ?PROP #$True) (#$ist #$BaseKB ?PROP)) #$Forward-AssertionDirection)) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that a forward rule concluding to #$True does not cause a canonicalizer error.")
  2647. ;;; Result(62)  <==== #<INFERENCE-UNIT-TEST 0>
  2648. ;;; CYC(63): (DEFINE-INFERENCE-UNIT-TEST :FORWARD-RULE-CONCLUDING-FALSE :OWNER "jantos" :CREATOR "pace" :BUG 18909 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$implies (#$equalSymbols ?PROP #$False) (#$ist #$BaseKB ?PROP)) (#$assertionDirection (#$implies (#$equalSymbols ?PROP #$False) (#$ist #$BaseKB ?PROP)) #$Forward-AssertionDirection)) (#$isa #$Thing #$Thing)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :TAUTOLOGY :COMMENT "Test that a forward rule concluding to #$False canonicalizes to a tautology")
  2649. ;;; Result(63)  <==== #<INFERENCE-UNIT-TEST 0>
  2650. ;;; CYC(64): (DEFINE-INFERENCE-UNIT-TEST :SCOPED-VARIABLE-EXPANSION :CREATOR "goolsbey" :OWNER "pace" :BUG 22788 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$ELRelation-OneWay) (#$expansion ?PRED (#$thereExists ?N (#$and (#$evaluate ?N (#$PlusFn :ARG1 :ARG1)) (#$evaluate :ARG2 (#$TimesFn ?N ?N)))))) (?PRED 1 ?ANS)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?ANS . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Verify that an ELRelation that has an expansion
  2651.    with a scoped variable works properly.")
  2652. ;;; Result(64)  <==== #<INFERENCE-UNIT-TEST 0>
  2653. ;;; CYC(65): (DEFINE-INFERENCE-UNIT-TEST :SCOPED-VARIABLE-EXPANSION-SPLIT :CREATOR "goolsbey" :OWNER "pace" :BUG 22788 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$ELRelation-OneWay) (#$expansion ?PRED (#$thereExists ?N (#$and (#$evaluate ?N (#$PlusFn :ARG1 :ARG1)) (#$evaluate :ARG2 (#$TimesFn ?N ?N)))))) (#$and (?PRED 1 ?ANS-1) (?PRED 2 ?ANS-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?ANS-1 . 4) (?ANS-2 . 16)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Verify that an ELRelation that has an expansion
  2654.    with a scoped variable works properly in splits.")
  2655. ;;; Result(65)  <==== #<INFERENCE-UNIT-TEST 0>
  2656. ;;; CYC(66): (DEFINE-INFERENCE-UNIT-TEST :SCOPED-VARIABLE-EXPANSION-CHAINED :CREATOR "goolsbey" :OWNER "pace" :BUG 22788 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?PRED #$BinaryPredicate) (#$isa ?PRED #$ELRelation-OneWay) (#$expansion ?PRED (#$thereExists ?N (#$and (#$evaluate ?N (#$PlusFn :ARG1 :ARG1)) (#$evaluate :ARG2 (#$TimesFn ?N ?N)))))) (#$and (?PRED 1 ?ANS-1) (?PRED ?ANS-1 ?ANS-2))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (QUOTE (((?ANS-1 . 4) (?ANS-2 . 64)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Verify that an ELRelation that has an expansion
  2657.    with a scoped variable works properly when chained.")
  2658. ;;; Result(66)  <==== #<INFERENCE-UNIT-TEST 0>
  2659. ;;; CYC(67): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-VARIABLES-WITH-SAME-EVALUATION :CREATOR "jantos" :OWNER "jantos" :BUG 23070 :KB :TINY :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$evaluate ?N (#$PlusFn 2 2)) (#$evaluate ?M (#$PlusFn 2 2))))) :EXPECTED-RESULT (QUOTE (((?N . 4) (?M . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Verify that isomorphic evaluates don't confuse the inference czer.")
  2660. ;;; Result(67)  <==== #<INFERENCE-UNIT-TEST 0>
  2661. ;;; CYC(68): (DEFINE-INFERENCE-UNIT-TEST :MULTIPLE-VARIABLES-WITH-SAME-TERM-OF-UNIT :CREATOR "jantos" :OWNER "jantos" :BUG 23070 :KB :FULL :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$termOfUnit ?N (#$JuvenileFn #$Dog)) (#$termOfUnit ?M (#$JuvenileFn #$Dog))))) :EXPECTED-RESULT (QUOTE (((?N #$JuvenileFn #$Dog) (?M #$JuvenileFn #$Dog)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Verify that isomorphic #$termOfUnit literals don't confuse the inference czer.")
  2662. ;;; Result(68)  <==== #<INFERENCE-UNIT-TEST 0>
  2663. ;;; CYC(69): :EOF
  2664. ;;; ... w:\cyc\top\tests\czer-unit-test-cases.lisp loaded; SHA-1: 11caf8a869f4148208e2d15ca509d63ceb5667f5
  2665. ;;; loading w:\cyc\top\tests\kb-invariant-test-cases.lisp ...
  2666. ;;; CYC(1): (IN-PACKAGE "CYC")
  2667. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2668. ;;; CYC(2): (CVS-ID "$Id: kb-invariant-test-cases.lisp 126640 2008-12-04 13:39:36Z builder $")
  2669. ;;; Result(2)  <==== CL:NIL
  2670. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :THING-ISA-THING :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$isa #$Thing #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is Thing a Thing?")
  2671. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2672. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :THING-ISA-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$isa #$Thing #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is Thing a Collection?")
  2673. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2674. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :THINGS-ARE-THINGS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$genls #$Thing #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are Things Things?")
  2675. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2676. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :COLLECTIONS-ARE-THINGS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$genls #$Collection #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are Collections Things?")
  2677. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2678. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :COLLECTIONS-ARE-COLLECTIONS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$genls #$Collection #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are Collections Collections?")
  2679. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2680. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :INDIVIDUALS-ARE-THINGS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$CoreCycLMt (#$genls #$Individual #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are Individuals Things?")
  2681. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2682. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :DAY-OF-WEEK-TYPE-ISA-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$DayOfWeekType #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is DayOfWeekType a Collection?")
  2683. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2684. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :MONTHS-ARE-INDIVIDUALS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$genls #$December #$Individual))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are Months Individuals?")
  2685. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2686. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :OBJECTTYPE-ISA-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$ObjectType #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Is ObjectType a Collection?")
  2687. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2688. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :OBJECTTYPES-ARE-COLLECTIONS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$genls #$ObjectType #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Are ObjectTypes Collections?")
  2689. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2690. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :EXISTINGOBJECTTYPE-ISA-COLLECTION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa #$ExistingObjectType #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Is ExistingObjectType a Collection?")
  2691. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2692. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :EXISTINGOBJECTTYPES-ARE-COLLECTIONS :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$genls #$ExistingObjectType #$Collection))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Are ExistingObjectTypes Collections?")
  2693. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2694. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :EXISTINGOBJECTTYPES-ARE-OBEJCTTYPES :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$genls #$ExistingObjectType #$ObjectType))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :FULL :COMMENT "Are ExistingObjectTypes ObjectTypes?")
  2695. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2696. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :2-IS-A-SCALAR-INTERVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 2 #$ScalarInterval))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is 2 a ScalarInterval?")
  2697. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2698. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :2-IS-AN-INTEGER :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 2 #$Integer))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is 2 an Integer?")
  2699. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2700. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :2-IS-A-POSITIVE-INTEGER :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 2 #$PositiveInteger))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is 2 a PositiveInteger?")
  2701. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2702. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :2-IS-AN-INDIVIDUAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 2 #$Individual))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is 2 an Individual?")
  2703. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  2704. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :2-IS-A-THING :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$isa 2 #$Thing))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Is 2 a Thing?")
  2705. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  2706. ;;; CYC(21): (DEFINE-INFERENCE-UNIT-TEST :UNARY-PREDICATES-ARE-NOT-BINARY :OWNER "pace" :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$disjointWith #$UnaryPredicate #$BinaryPredicate))) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :KB :BOTH :COMMENT "Are unary predicates disjoint with binary predicates?")
  2707. ;;; Result(21)  <==== #<INFERENCE-UNIT-TEST 0>
  2708. ;;; CYC(22): :EOF
  2709. ;;; ... w:\cyc\top\tests\kb-invariant-test-cases.lisp loaded; SHA-1: 3521cb852a38f35fa115a8dfd94e08f14c39675f
  2710. ;;; loading w:\cyc\top\tests\ist-rule-transformation-tests.lisp ...
  2711. ;;; CYC(1): (IN-PACKAGE "CYC")
  2712. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2713. ;;; CYC(2): (CVS-ID "$Id: ist-rule-transformation-tests.lisp 126640 2008-12-04 13:39:36Z builder $")
  2714. ;;; Result(2)  <==== CL:NIL
  2715. ;;; CYC(3): (DEFINE-INFERENCE-TEST :CLOSED-MT-IST-BACKWARD-TEST (:COMMENT "test backward inference with closed-mt ist rules" :OWNER "kknight" :KB :TINY :WORKING? NIL :DIRECTION :BACKWARD) (WITH-TEST-CONSTANTS T (((MT-A MT-B MT-AB MT-C-1 MT-C-2 MT-C-3) #$Microtheory) ((PRED-1 PRED-2 PRED-3 PRED-4 PRED-5) #$UnaryPredicate) ((OBJ-1 OBJ-2) #$Individual)) (PRINT-ASSERT (BQ-LIST (BQ-LIST #$genlMt MT-AB MT-A) (BQ-LIST #$genlMt MT-AB MT-B) (BQ-LIST #$genlMt MT-C-2 MT-C-1) (BQ-LIST #$genlMt MT-C-3 MT-C-2)) #$BaseKB :MONOTONIC :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST #$ist MT-C-2 (BQ-LIST #$implies (BQ-CONS PRED-1 (QUOTE (?X))) (BQ-CONS PRED-2 (QUOTE (?X))))) (BQ-LIST #$implies (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-1 (QUOTE (?X)))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-3 (QUOTE (?X))))) (BQ-LIST #$implies (BQ-LIST #$and (BQ-CONS PRED-4 (QUOTE (?X))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-1 (QUOTE (?X))))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-5 (QUOTE (?X)))))) MT-B :DEFAULT :BACKWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-1 OBJ-1)) MT-C-1 :DEFAULT :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-1 OBJ-2)) MT-C-3 :DEFAULT :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-4 OBJ-1)) MT-A :DEFAULT :FORWARD) (B-VERIFY (BQ-LIST PRED-2 OBJ-1) MT-C-2 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1))) (B-VERIFY (BQ-LIST PRED-2 OBJ-2) MT-C-3 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1))) (B-VERIFY (BQ-LIST PRED-3 OBJ-1) MT-C-2 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1))) (VERIFY-NOT (BQ-LIST PRED-3 OBJ-2) MT-C-3 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1))) (B-VERIFY (BQ-LIST PRED-5 OBJ-1) MT-C-2 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1))) (VERIFY-NOT (BQ-LIST PRED-5 OBJ-2) MT-C-3 (QUOTE (:MAX-TRANSFORMATION-DEPTH 1)))))
  2716. ;;; Result(3)  <==== :CLOSED-MT-IST-BACKWARD-TEST
  2717. ;;; CYC(4): (DEFINE-INFERENCE-TEST :CLOSED-MT-IST-FORWARD-TEST (:COMMENT "test forward inference with closed-mt ist rules" :OWNER "kknight" :KB :TINY :WORKING? NIL :DIRECTION :BACKWARD) (WITH-TEST-CONSTANTS T (((MT-A MT-B MT-AB MT-C-1 MT-C-2 MT-C-3) #$Microtheory) ((PRED-1 PRED-2 PRED-3 PRED-4 PRED-5) #$UnaryPredicate) ((OBJ-1 OBJ-2) #$Individual)) (PRINT-ASSERT (BQ-LIST (BQ-LIST #$genlMt MT-AB MT-A) (BQ-LIST #$genlMt MT-AB MT-B) (BQ-LIST #$genlMt MT-C-2 MT-C-1) (BQ-LIST #$genlMt MT-C-3 MT-C-2)) #$BaseKB :MONOTONIC :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST #$ist MT-C-2 (BQ-LIST #$implies (BQ-CONS PRED-1 (QUOTE (?X))) (BQ-CONS PRED-2 (QUOTE (?X))))) (BQ-LIST #$implies (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-1 (QUOTE (?X)))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-3 (QUOTE (?X))))) (BQ-LIST #$implies (BQ-LIST #$and (BQ-CONS PRED-4 (QUOTE (?X))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-1 (QUOTE (?X))))) (BQ-LIST #$ist MT-C-2 (BQ-CONS PRED-5 (QUOTE (?X)))))) MT-B :DEFAULT :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-1 OBJ-1)) MT-C-1 :DEFAULT :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-1 OBJ-2)) MT-C-3 :DEFAULT :FORWARD) (PRINT-ASSERT (BQ-LIST (BQ-LIST PRED-4 OBJ-1)) MT-A :DEFAULT :FORWARD) (B-VERIFY (BQ-LIST PRED-2 OBJ-1) MT-C-2 (QUOTE (:TRANSFORMATION-ALLOWED? NIL))) (B-VERIFY (BQ-LIST PRED-2 OBJ-2) MT-C-3 (QUOTE (:TRANSFORMATION-ALLOWED? NIL))) (B-VERIFY (BQ-LIST PRED-3 OBJ-1) MT-C-2 (QUOTE (:TRANSFORMATION-ALLOWED? NIL))) (VERIFY-NOT (BQ-LIST PRED-3 OBJ-2) MT-C-3 (QUOTE (:TRANSFORMATION-ALLOWED? NIL))) (B-VERIFY (BQ-LIST PRED-5 OBJ-1) MT-C-2 (QUOTE (:TRANSFORMATION-ALLOWED? NIL))) (VERIFY-NOT (BQ-LIST PRED-5 OBJ-2) MT-C-3 (QUOTE (:TRANSFORMATION-ALLOWED? NIL)))))
  2718. ;;; Result(4)  <==== :CLOSED-MT-IST-FORWARD-TEST
  2719. ;;; CYC(5): (PWHEN-FEATURE :CYC-TESTING (PWHEN-FEATURE :CYC-SUNIT-FULL (PWHEN-FEATURE :CYC-SUNIT)))
  2720. ;;; Result(5)  <==== CL:NIL
  2721. ;;; CYC(6): :EOF
  2722. ;;; ... w:\cyc\top\tests\ist-rule-transformation-tests.lisp loaded; SHA-1: af7a094746cdadd123112a30483d90389bd784a6
  2723. ;;; loading w:\cyc\top\tests\pruning-tests.lisp ...
  2724. ;;; CYC(1): (IN-PACKAGE "CYC")
  2725. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2726. ;;; CYC(2): (CVS-ID "$Id: pruning-tests.lisp 129050 2009-10-28 16:49:31Z pace $")
  2727. ;;; Result(2)  <==== CL:NIL
  2728. ;;; CYC(3): (DEFINE-PRIVATE CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO (PROBLEM-COUNT LINK-COUNT PROOF-COUNT) "@return booleanp; whether the currently active problem store has
  2729.    PROBLEM-COUNT or fewer problems,
  2730.    LINK-COUNT or fewer links, and
  2731.    PROOF-COUNT or fewer proofs." (CLET ((STORE (CURRENTLY-ACTIVE-PROBLEM-STORE))) (RET (COUNTS-LESS-THAN-OR-EQUAL-TO (PROBLEM-STORE-PROBLEM-COUNT STORE) PROBLEM-COUNT (PROBLEM-STORE-LINK-COUNT STORE) LINK-COUNT (PROBLEM-STORE-PROOF-COUNT STORE) PROOF-COUNT))))
  2732. ;;; Result(3)  <==== {CYC:CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO -SubLInterpretedFunction-}
  2733. ;;; CYC(4): (DEFINE-PRIVATE COUNTS-LESS-THAN-OR-EQUAL-TO (ACTUAL-PROBLEM-COUNT EXPECTED-PROBLEM-COUNT ACTUAL-LINK-COUNT EXPECTED-LINK-COUNT ACTUAL-PROOF-COUNT EXPECTED-PROOF-COUNT) (RET (CAND (<= ACTUAL-PROBLEM-COUNT EXPECTED-PROBLEM-COUNT) (<= ACTUAL-LINK-COUNT EXPECTED-LINK-COUNT) (<= ACTUAL-PROOF-COUNT EXPECTED-PROOF-COUNT))))
  2734. ;;; Result(4)  <==== {CYC:COUNTS-LESS-THAN-OR-EQUAL-TO -SubLInterpretedFunction-}
  2735. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-SINGLE-LITERAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$integerBetween 0 ?NUM 1))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 0)) ((?NUM . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 2 3 1)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a single-literal query")
  2736. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2737. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-JOIN-ORDERED :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$integerBetween 0 ?NUM 1) (#$trueSubL (#$ExpandSubLFn (?NUM) (BOOLEAN ?NUM)))))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 0)) ((?NUM . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 5 9 5)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a simple join-ordered query")
  2738. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2739. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-GENLS-BETWEEN-CONJUNCTIVE-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-A #$Collection) (#$isa ?COL-B #$Collection) (#$isa ?COL-C #$Collection) (#$isa ?COL-D #$Collection) (#$isa ?COL-E #$Collection) (#$genls ?COL-A ?COL-B) (#$genls ?COL-B ?COL-C) (#$genls ?COL-C ?COL-D) (#$genls ?COL-D ?COL-E) (#$completeExtentEnumerable #$genls)) (#$and (#$genls ?COL-A ?COL) (#$genls ?COL ?COL-E))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?COL . ?COL-A)) ((?COL . ?COL-B)) ((?COL . ?COL-C)) ((?COL . ?COL-D)) ((?COL . ?COL-E)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 2 3 1)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a conjunctive removal query")
  2740. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2741. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-GENLS-BETWEEN-PARTIAL-CONJUNCTIVE-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?COL-A #$Collection) (#$isa ?COL-B #$Collection) (#$isa ?COL-C #$Collection) (#$isa ?COL-D #$Collection) (#$isa ?COL-E #$Collection) (#$genls ?COL-A ?COL-B) (#$genls ?COL-B ?COL-C) (#$genls ?COL-C ?COL-D) (#$genls ?COL-D ?COL-E) (#$completeExtentEnumerable #$genls)) (#$and (#$genls ?COL-A ?COL) (#$genls ?COL ?COL-E) (#$trueSubL (#$ExpandSubLFn (?COL) (BOOLEAN ?COL))))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :RETURN :BINDINGS-AND-HYPOTHETICAL-BINDINGS)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?COL . ?COL-A)) ((?COL . ?COL-B)) ((?COL . ?COL-C)) ((?COL . ?COL-D)) ((?COL . ?COL-E)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 9 15 12)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a query part of which is solved by conjunctive removal and the other part of which is solved by join-ordered")
  2742. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2743. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-CONJUNCTIVE-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?NUM #$Integer) (#$greaterThanOrEqualTo ?NUM 1) (#$greaterThanOrEqualTo 5 ?NUM)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)) ((?NUM . 3)) ((?NUM . 4)) ((?NUM . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 2 3 1)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a conjunctive removal query")
  2744. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2745. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-CONJUNCTIVE-REMOVAL-100 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?NUM #$Integer) (#$greaterThanOrEqualTo ?NUM 1) (#$greaterThanOrEqualTo 100 ?NUM)))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT 100 :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 2 3 1)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a conjunctive removal query")
  2746. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2747. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-CONJUNCTIVE-REMOVAL-AFTER-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GE-PRED #$BinaryPredicate) (#$backchainRequired ?GE-PRED) (#$implies (#$greaterThanOrEqualTo ?A ?B) (?GE-PRED ?A ?B))) (#$and (#$isa ?NUM #$Integer) (?GE-PRED ?NUM 1) (?GE-PRED 5 ?NUM))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)) ((?NUM . 3)) ((?NUM . 4)) ((?NUM . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 10 10 3)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a conjunctive removal query after a transformation")
  2748. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2749. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-CONJUNCTIVE-REMOVAL-AFTER-TRANSFORMATION-100 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GE-PRED #$BinaryPredicate) (#$backchainRequired ?GE-PRED) (#$implies (#$greaterThanOrEqualTo ?A ?B) (?GE-PRED ?A ?B))) (#$and (#$isa ?NUM #$Integer) (?GE-PRED ?NUM 1) (?GE-PRED 100 ?NUM))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :PRODUCTIVITY-LIMIT :POSITIVE-INFINITY :MAX-TRANSFORMATION-DEPTH 1)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT 100 :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 10 10 3)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a conjunctive removal query after a transformation")
  2750. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2751. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-PARTIAL-CONJUNCTIVE-REMOVAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?NUM #$Integer) (#$greaterThanOrEqualTo ?NUM 1) (#$greaterThanOrEqualTo 5 ?NUM) (#$trueSubL (#$ExpandSubLFn (?NUM) (BOOLEAN ?NUM)))))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)) ((?NUM . 3)) ((?NUM . 4)) ((?NUM . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 5 7 4)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a query part of which is solved by conjunctive removal and the other part of which is solved by join-ordered")
  2752. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2753. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-PARTIAL-CONJUNCTIVE-REMOVAL-100 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$and (#$isa ?NUM #$Integer) (#$greaterThanOrEqualTo ?NUM 1) (#$greaterThanOrEqualTo 100 ?NUM) (#$trueSubL (#$ExpandSubLFn (?NUM) (BOOLEAN ?NUM)))))) :PROPERTIES (QUOTE (:BROWSABLE? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT 100 :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 5 7 4)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a query part of which is solved by conjunctive removal and the other part of which is solved by join-ordered")
  2754. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2755. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-PARTIAL-CONJUNCTIVE-REMOVAL-AFTER-TRANSFORMATION :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GE-PRED #$BinaryPredicate) (#$backchainRequired ?GE-PRED) (#$implies (#$greaterThanOrEqualTo ?A ?B) (?GE-PRED ?A ?B))) (#$and (#$isa ?NUM #$Integer) (?GE-PRED ?NUM 1) (?GE-PRED 5 ?NUM) (#$trueSubL (#$ExpandSubLFn (?NUM) (BOOLEAN ?NUM))))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?NUM . 1)) ((?NUM . 2)) ((?NUM . 3)) ((?NUM . 4)) ((?NUM . 5)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 19 29 14)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a query part of which is solved by conjunctive removal and the other part of which is solved by join-ordered")
  2756. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2757. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-PARTIAL-CONJUNCTIVE-REMOVAL-AFTER-TRANSFORMATION-100 :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GE-PRED #$BinaryPredicate) (#$backchainRequired ?GE-PRED) (#$implies (#$greaterThanOrEqualTo ?A ?B) (?GE-PRED ?A ?B))) (#$and (#$isa ?NUM #$Integer) (?GE-PRED ?NUM 1) (?GE-PRED 100 ?NUM) (#$trueSubL (#$ExpandSubLFn (?NUM) (BOOLEAN ?NUM))))))) :PROPERTIES (QUOTE (:BROWSABLE? T :CONDITIONAL-SENTENCE? T :MAX-TRANSFORMATION-DEPTH 1)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT 100 :EXPECTED-RESULT-TEST (QUOTE LENGTH=) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 15 21 6)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a query part of which is solved by conjunctive removal and the other part of which is solved by join-ordered")
  2758. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2759. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-RT-LINK-WITH-SIBLING-T-LINK-PROOFS :OWNER "pace" :BUG 22972 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?RDF-TYPE #$BinaryPredicate) (#$isa ?ISA #$BinaryPredicate) (#$isa ?STRING-FN #$UnaryFunction) (#$isa ?CVIR-QUALIFYING-OPERATION #$Collection) (#$implies (?RDF-TYPE ?INS ?COL) (?ISA ?INS ?COL)) (?RDF-TYPE (?STRING-FN "abc") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "defg") ?CVIR-QUALIFYING-OPERATION)) (#$thereExists ?OP (#$thereExists ?STRING (#$and (?ISA ?OP ?CVIR-QUALIFYING-OPERATION) (#$evaluate ?STRING (#$EvaluateSubLFn (#$ExpandSubLFn (?OP) (FORMULA-ARG1 (QUOTE ?OP))))) (#$evaluate ?LEN (#$EvaluateSubLFn (#$ExpandSubLFn (?STRING) (LENGTH ?STRING)))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?LEN . 3)) ((?LEN . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 16 21 12)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a case where there is an RT link and a sibling dead-end T link, and we want to prune the T link's proofs")
  2760. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2761. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-RT-LINK-WITH-SIBLING-T-LINK-PROOFS-MORE-DATA :OWNER "pace" :BUG 22972 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?RDF-TYPE #$BinaryPredicate) (#$isa ?ISA #$BinaryPredicate) (#$isa ?STRING-FN #$UnaryFunction) (#$isa ?CVIR-QUALIFYING-OPERATION #$Collection) (#$implies (?RDF-TYPE ?INS ?COL) (?ISA ?INS ?COL)) (?RDF-TYPE (?STRING-FN "abc") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "defg") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "hkj") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "paks") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "oora") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "oram") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "mrar") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "orz") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "zoa") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "imr") ?CVIR-QUALIFYING-OPERATION) (?RDF-TYPE (?STRING-FN "mmr") ?CVIR-QUALIFYING-OPERATION)) (#$thereExists ?OP (#$thereExists ?STRING (#$and (?ISA ?OP ?CVIR-QUALIFYING-OPERATION) (#$evaluate ?STRING (#$EvaluateSubLFn (#$ExpandSubLFn (?OP) (FORMULA-ARG1 (QUOTE ?OP))))) (#$evaluate ?LEN (#$EvaluateSubLFn (#$ExpandSubLFn (?STRING) (LENGTH ?STRING)))))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?LEN . 3)) ((?LEN . 4)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 22 27 18)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test pruning for a case where there is an RT link and a sibling dead-end T link, and we want to prune the T link's proofs")
  2762. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2763. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :DONT-PRUNE-FOCAL-WITH-IN-PROGRESS-RESTRICTED-NON-FOCAL :OWNER "pace" :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?GE-PRED #$BinaryPredicate) (#$backchainRequired ?GE-PRED) (#$implies (#$greaterThanOrEqualTo ?X ?Y) (?GE-PRED ?X ?Y))) (#$and (#$elementOf ?N (#$TheSet -99 1 2)) (?GE-PRED ?N ?ANSWER) (?GE-PRED ?ANSWER 0) (#$isa ?ANSWER #$Integer))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1 :ADD-RESTRICTION-LAYER-OF-INDIRECTION? T)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?N . 2) (?ANSWER . 0)) ((?N . 2) (?ANSWER . 1)) ((?N . 2) (?ANSWER . 2)) ((?N . 1) (?ANSWER . 0)) ((?N . 1) (?ANSWER . 1)))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 18 24 9)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Distilled from #$CCF-FindAllDescendingAortaVP")
  2764. ;;; Result(19)  <==== #<INFERENCE-UNIT-TEST 0>
  2765. ;;; CYC(20): (DEFINE-INFERENCE-UNIT-TEST :PRUNE-PROOF-WITH-DONT-CARE-VARIABLE :OWNER "pace" :BUG 23046 :SENTENCE (QUOTE (#$ist #$BaseKB (#$implies (#$and (#$isa ?P #$BinaryPredicate) (#$isa ?Q #$UnaryPredicate) (#$implies (#$and (?P ?X ??WHATEVER) (#$quotedIsa ?X #$SubLString)) (?Q ?X)) (?P "a" 1) (?P "a" 2) (?P "a" 3)) (#$and (?Q ?WHAT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T :BROWSABLE? T :MAX-TRANSFORMATION-DEPTH 1)) :BINDINGS (QUOTE ((*TEST-REAL-TIME-PRUNING?* T) (*BALANCING-TACTICIAN?* T))) :EXPECTED-RESULT (QUOTE (((?WHAT . "a")))) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :FOLLOWUPS (QUOTE ((:SENTENCE (#$ist #$BaseKB (#$trueSubL (#$SubLQuoteFn (CURRENTLY-ACTIVE-PROBLEM-STORE-COUNTS-LESS-THAN-OR-EQUAL-TO 7 11 6)))) :EXPECTED-RESULT (NIL)))) :COMMENT "Test that when proofs bubble up through a transformation link and merge with existing proofs, they get marked as processed and then pruned.")
  2766. ;;; Result(20)  <==== #<INFERENCE-UNIT-TEST 0>
  2767. ;;; CYC(21): :EOF
  2768. ;;; ... w:\cyc\top\tests\pruning-tests.lisp loaded; SHA-1: b049db036ecde0fcd43b518b72e026dd8fad0b01
  2769. ;;; loading w:\cyc\top\tests\temporal-subsumption-unit-test-cases.lisp ...
  2770. ;;; CYC(1): (IN-PACKAGE "CYC")
  2771. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2772. ;;; CYC(2): (CVS-ID "$Id: temporal-subsumption-unit-test-cases.lisp 126640 2008-12-04 13:39:36Z builder $")
  2773. ;;; Result(2)  <==== CL:NIL
  2774. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-TYPETYPE--CALENDAR-DAY>1DAY :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-TypeType #$CalendarDay (#$SameLengthTimeIntervalTypeFn (#$DaysDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that every CalendarDay subsumes some instance of 1 Day duration intervals.")
  2775. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2776. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-TYPETYPE--10DAYS>CALENDAR-DAY :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-TypeType (#$SameLengthTimeIntervalTypeFn (#$DaysDuration 10)) #$CalendarDay))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that every 10 Day duration interval subsumes some instance of CalendarDay.")
  2777. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2778. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-TYPETYPE--2DAYS>1DAY :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-TypeType (#$SameLengthTimeIntervalTypeFn (#$DaysDuration 2)) (#$SameLengthTimeIntervalTypeFn (#$DaysDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that every 2 day duartion interval subsumes some 1 day duration interval.")
  2779. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2780. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-INSTYPE--2000>CALENDAR-YEAR :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-InsType (#$YearFn 2000) #$CalendarYear))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the year 2000 subsumes some instance of CalendarYear.")
  2781. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2782. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-INSTYPE--2000>1YEAR :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-InsType (#$YearFn 2000) (#$SameLengthTimeIntervalTypeFn (#$YearsDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the year 2000 subsumes some instance of 1 year duration intervals")
  2783. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2784. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMES-INSTYPE--THEYEAR2000>1YEAR :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumes-InsType #$TheYear2000 (#$SameLengthTimeIntervalTypeFn (#$YearsDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that TheYear2000 subsumes some instance of 1 year duration intervals")
  2785. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2786. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMED-BY-INSTYPE-2000<CALENDAR-YEAR :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumedBy-InsType (#$YearFn 2000) #$CalendarYear))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the year 2000 is subsumed by some instance of #$CalendarYear.")
  2787. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2788. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMED-BY-INSTYPE-2000<1YEAR :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumedBy-InsType (#$YearFn 2000) (#$SameLengthTimeIntervalTypeFn (#$YearsDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that the year 2000 is subsumed by some instance of 1 year duration intervals")
  2789. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2790. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMED-BY-INSTYPE-THEYEAR2000<1YEAR :OWNER "kknight" :CREATOR "hagen" :WORKING? NIL :BUG 10816 :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumedBy-InsType #$TheYear2000 (#$SameLengthTimeIntervalTypeFn (#$YearsDuration 1))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that TheYear2000 is subsumed by some instance of 1 year duration intervals")
  2791. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2792. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :TEMPORALLY-SUBSUMED-BY-INSTYPE-TIME-INTERVAL<5DAYS :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$temporallySubsumedBy-InsType (#$TimeIntervalInclusiveFn (#$DayFn 28 (#$MonthFn #$June (#$YearFn 1968))) (#$DayFn 2 (#$MonthFn #$July (#$YearFn 1968)))) (#$SameLengthTimeIntervalTypeFn (#$DaysDuration 5))))) :PROPERTIES NIL :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that June 28 - July 2 is a 5 day period.")
  2793. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2794. ;;; CYC(13): :EOF
  2795. ;;; ... w:\cyc\top\tests\temporal-subsumption-unit-test-cases.lisp loaded; SHA-1: b8a910359b369cae1d57ae8f1ca057381ca04310
  2796. ;;; loading w:\cyc\top\tests\inference-rewrite-unit-test-cases.lisp ...
  2797. ;;; CYC(1): (IN-PACKAGE "CYC")
  2798. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2799. ;;; CYC(2): (CVS-ID "$Id: inference-rewrite-unit-test-cases.lisp 126640 2008-12-04 13:39:36Z builder $")
  2800. ;;; Result(2)  <==== CL:NIL
  2801. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :RAI-GROUP-MEMBER-TYPES-FROM-GROUP-TYPE-MEMBER-TYPE-REWRITE-1 :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FORT1 #$ObjectType) (#$genls ?FORT1 #$Group) (#$isa ?FORT2 #$Collection) (#$genls ?FORT2 #$TemporalThing) (#$groupTypeMemberType ?FORT1 ?FORT2)) (#$relationAllInstance #$groupMemberType ?FORT1 ?FORT2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$relationAllExists #$groupMemberType <fort1>
  2802.   <fort2>) problems are successfully rewritten as (#$groupTypeMemberType
  2803.   <fort1> <fort2>) problems and solved.")
  2804. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2805. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :RAI-GROUP-MEMBER-TYPES-FROM-GROUP-TYPE-MEMBER-TYPE-REWRITE-2 :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?TERM #$Collection) (#$genls ?TERM #$TemporalThing) (#$comment (#$GroupFn ?TERM) "Thinking of this term")) (#$relationAllInstance #$groupMemberType (#$GroupFn ?TERM) ?TERM)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$relationAllExists #$groupMemberType <fort1>
  2806.   <fort2>) problems are successfully rewritten as (#$groupTypeMemberType
  2807.   <fort1> <fort2>) problems and solved.")
  2808. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2809. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :GROUP-TYPE-MEMBER-TYPE-FROM-RAI-GROUP-MEMBER-TYPES-REWRITE-1 :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?FORT1 #$ObjectType) (#$genls ?FORT1 #$Group) (#$isa ?FORT2 #$Collection) (#$genls ?FORT2 #$TemporalThing) (#$relationAllInstance #$groupMemberType ?FORT1 ?FORT2)) (#$groupTypeMemberType ?FORT1 ?FORT2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$groupTypeMemberType <fort1> <fort2>) problems are
  2810.   successfully rewritten as (#$relationAllInstance #$groupMemberType <fort1>
  2811.   <fort2>) problems and solved.")
  2812. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2813. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :GROUP-TYPE-MEMBER-TYPE-FROM-RAI-GROUP-MEMBER-TYPES-REWRITE-2 :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?TERM #$Collection) (#$genls ?TERM #$TemporalThing) (#$relationAllInstance #$groupMemberType (#$GroupFn ?TERM) ?TERM)) (#$groupTypeMemberType (#$GroupFn ?TERM) ?TERM)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$groupTypeMemberType <fort1> <fort2>) problems are
  2814.   successfully rewritten as (#$relationAllInstance #$groupMemberType <fort1>
  2815.   <fort2>) problems and solved.")
  2816. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2817. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :RAL-SUB-EVENTS-FROM-SUB-EVENT-TYPES-REWRITE :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?EV-TYPE-1 #$FirstOrderCollection) (#$genls ?EV-TYPE-1 #$Event) (#$isa ?EV-TYPE-2 #$FirstOrderCollection) (#$genls ?EV-TYPE-2 #$Event) (#$subEventTypes ?EV-TYPE-1 ?EV-TYPE-2)) (#$relationAllExists #$subEvents ?EV-TYPE-1 ?EV-TYPE-2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$relationAllExists #$subEvents <fort1>
  2818.   <fort2>) problems are successfully rewritten as (#$subEventTypes
  2819.   <fort1> <fort2>) problems and solved.")
  2820. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2821. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :SUB-EVENT-TYPES-FROM-RAL-SUB-EVENTS-REWRITE :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?EV-TYPE-1 #$FirstOrderCollection) (#$genls ?EV-TYPE-1 #$Event) (#$isa ?EV-TYPE-2 #$FirstOrderCollection) (#$genls ?EV-TYPE-2 #$Event) (#$relationAllExists #$subEvents ?EV-TYPE-1 ?EV-TYPE-2)) (#$subEventTypes ?EV-TYPE-1 ?EV-TYPE-2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$subEventTypes <fort1> <fort2>) problems are
  2822.   successfully rewritten as (#$relationAllExists #$subEvents <fort1>
  2823.   <fort2>) problems and solved.")
  2824. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2825. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :RAL-SUB-SITUATIONS-FROM-SUB-SITUATION-TYPES-REWRITE :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SIT-TYPE-1 #$FirstOrderCollection) (#$genls ?SIT-TYPE-1 #$Situation) (#$isa ?SIT-TYPE-2 #$FirstOrderCollection) (#$genls ?SIT-TYPE-2 #$Situation) (#$subSituationTypes ?SIT-TYPE-1 ?SIT-TYPE-2)) (#$relationAllExists #$subSituations ?SIT-TYPE-1 ?SIT-TYPE-2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$relationAllExists #$subSituations <fort1>
  2826.   <fort2>) problems are successfully rewritten as (#$subSituationTypes
  2827.   <fort1> <fort2>) problems and solved.")
  2828. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2829. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :SUB-SITUATION-TYPES-FROM-RAL-SUB-SITUATIONS-REWRITE :OWNER "blake" :WORKING? T :BUG 10817 :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?SIT-TYPE-1 #$FirstOrderCollection) (#$genls ?SIT-TYPE-1 #$Situation) (#$isa ?SIT-TYPE-2 #$FirstOrderCollection) (#$genls ?SIT-TYPE-2 #$Situation) (#$relationAllExists #$subSituations ?SIT-TYPE-1 ?SIT-TYPE-2)) (#$subSituationTypes ?SIT-TYPE-1 ?SIT-TYPE-2)))) :PROPERTIES (QUOTE (:REWRITE-ALLOWED? T :CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test to ensure that (#$subSituationTypes <fort1> <fort2>) problems are
  2830.   successfully rewritten as (#$relationAllExists #$subSituations <fort1>
  2831.   <fort2>) problems and solved.")
  2832. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2833. ;;; CYC(11): :EOF
  2834. ;;; ... w:\cyc\top\tests\inference-rewrite-unit-test-cases.lisp loaded; SHA-1: 260db17d472a564eb0f0b584b9f242604501d2c8
  2835. ;;; loading w:\cyc\top\tests\mt-unit-test-cases.lisp ...
  2836. ;;; CYC(1): (IN-PACKAGE "CYC")
  2837. ;;; Result(1)  <==== #.(CL:FIND-PACKAGE "CYC")
  2838. ;;; CYC(2): (CVS-ID "$Id: mt-unit-test-cases.lisp 128970 2009-10-20 15:29:40Z pace $")
  2839. ;;; Result(2)  <==== CL:NIL
  2840. ;;; CYC(3): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-REFLEXIVE-GENL-MT :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt ?GENL-MT ?GENL-MT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive on microtheories.")
  2841. ;;; Result(3)  <==== #<INFERENCE-UNIT-TEST 0>
  2842. ;;; CYC(4): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-UNKNOWN-REFLEXIVE-NON-MT :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$genlMt #$Thing #$Thing))) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is not reflexive on non-microtheories.")
  2843. ;;; Result(4)  <==== #<INFERENCE-UNIT-TEST 0>
  2844. ;;; CYC(5): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-TO-VACUOUS-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt ?GENL-MT (#$MtSpace ?GENL-MT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "genlMt should be reflexive, even with a unary MtSpace around any combination of the mts.")
  2845. ;;; Result(5)  <==== #<INFERENCE-UNIT-TEST 0>
  2846. ;;; CYC(6): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-FROM-VACUOUS-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT) ?GENL-MT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "genlMt should be reflexive, even with a unary MtSpace around any combination of the mts.")
  2847. ;;; Result(6)  <==== #<INFERENCE-UNIT-TEST 0>
  2848. ;;; CYC(7): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-WITH-VACUOUS-MT-SPACES :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT) (#$MtSpace ?GENL-MT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "genlMt should be reflexive, even with a unary MtSpace around any combination of the mts.")
  2849. ;;; Result(7)  <==== #<INFERENCE-UNIT-TEST 0>
  2850. ;;; CYC(8): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-REDUNDANT :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt ?SPEC-MT ?GENL-MT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt between two monad mts is provable when asserted exactly as queried.")
  2851. ;;; Result(8)  <==== #<INFERENCE-UNIT-TEST 0>
  2852. ;;; CYC(9): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-TO-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt ?SPEC-MT (#$MtSpace ?GENL-MT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt between two monad mts is provable when asserted,
  2853. and when queried with a unary MtSpace around any combination of the mts.")
  2854. ;;; Result(9)  <==== #<INFERENCE-UNIT-TEST 0>
  2855. ;;; CYC(10): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-FROM-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?SPEC-MT) ?GENL-MT)))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt between two monad mts is provable when asserted,
  2856. and when queried with a unary MtSpace around any combination of the mts.")
  2857. ;;; Result(10)  <==== #<INFERENCE-UNIT-TEST 0>
  2858. ;;; CYC(11): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-WITHIN-MT-SPACES :OWNER "kknight" :CREATOR "hagen" :KB :TINY :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?SPEC-MT) (#$MtSpace ?GENL-MT))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt between two monad mts is provable when asserted,
  2859. and when queried with a unary MtSpace around any combination of the mts.")
  2860. ;;; Result(11)  <==== #<INFERENCE-UNIT-TEST 0>
  2861. ;;; CYC(12): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-1776 :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtTimeDimFn (#$YearFn 1776)) (#$MtTimeDimFn (#$YearFn 1776)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive between two purely time-index microtheories.")
  2862. ;;; Result(12)  <==== #<INFERENCE-UNIT-TEST 0>
  2863. ;;; CYC(13): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-1776-TO-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtTimeDimFn (#$YearFn 1776)) (#$MtSpace (#$MtTimeDimFn (#$YearFn 1776))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive between two purely time-index microtheories,
  2864. with any combination of unary MtSpace functions wrapped around them.")
  2865. ;;; Result(13)  <==== #<INFERENCE-UNIT-TEST 0>
  2866. ;;; CYC(14): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-1776-FROM-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace (#$MtTimeDimFn (#$YearFn 1776))) (#$MtTimeDimFn (#$YearFn 1776)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive between two purely time-index microtheories,
  2867. with any combination of unary MtSpace functions wrapped around them.")
  2868. ;;; Result(14)  <==== #<INFERENCE-UNIT-TEST 0>
  2869. ;;; CYC(15): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-1776-WITHIN-MT-SPACES :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace (#$MtTimeDimFn (#$YearFn 1776))) (#$MtSpace (#$MtTimeDimFn (#$YearFn 1776))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive between two purely time-index microtheories,
  2870. with any combination of unary MtSpace functions wrapped around them.")
  2871. ;;; Result(15)  <==== #<INFERENCE-UNIT-TEST 0>
  2872. ;;; CYC(16): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-1776-WITH-REFLEXIVE-MT :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT (#$MtTimeDimFn (#$YearFn 1776))) (#$MtSpace ?GENL-MT (#$MtTimeDimFn (#$YearFn 1776))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that genlMt is reflexive between two temporally indexed specMts
  2873. of an monad mt.")
  2874. ;;; Result(16)  <==== #<INFERENCE-UNIT-TEST 0>
  2875. ;;; CYC(17): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-FROM-1776-NULL-WITH-REFLEXIVE-MT :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT (#$MtTimeDimFn (#$YearFn 1776))) (#$MtSpace ?GENL-MT (#$MtTimeWithGranularityDimFn #$Always-TimeInterval #$TimePoint)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test that an mt with a year-long time index and
  2876. arbitrary time parameter is a specMt of an mt with no
  2877. specified time index (default = always) and a time
  2878. parameter of TimePoint, where the two share the same
  2879. monad mt.")
  2880. ;;; Result(17)  <==== #<INFERENCE-UNIT-TEST 0>
  2881. ;;; CYC(18): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-UNKNOWN-FROM-1776-NULL-TO-REFLEXIVE-NULL :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT (#$MtTimeWithGranularityDimFn (#$YearFn 1776) #$Null-TimeParameter)) (#$MtSpace ?GENL-MT (#$MtTimeWithGranularityDimFn #$Always-TimeInterval #$Null-TimeParameter)))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT NIL :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Just like the above test except it's not provable when the time
  2882. parameter of the genlMt is changed from TimePoint to Null-TimeParameter.")
  2883. ;;; Result(18)  <==== #<INFERENCE-UNIT-TEST 0>
  2884. ;;; CYC(19): (DEFINE-INFERENCE-UNIT-TEST :GENL-MT-FROM-1776-AND-MT-TO-1776-MT-SPACE :OWNER "kknight" :CREATOR "hagen" :KB :FULL :SENTENCE (QUOTE (#$ist #$UniversalVocabularyMt (#$implies (#$and (#$isa ?GENL-MT #$Microtheory) (#$genlMt ?GENL-MT #$UniversalVocabularyMt) (#$isa ?SPEC-MT #$Microtheory) (#$genlMt ?SPEC-MT ?GENL-MT)) (#$genlMt (#$MtSpace ?GENL-MT (#$MtTimeDimFn (#$YearFn 1776))) (#$MtSpace (#$MtTimeDimFn (#$YearFn 1776))))))) :PROPERTIES (QUOTE (:CONDITIONAL-SENTENCE? T)) :EXPECTED-RESULT (CLOSED-QUERY-SUCCESS-TOKEN) :EXPECTED-HALT-REASON :EXHAUST-TOTAL :COMMENT "Test where the time index is the same between spec and genlMts,