inference_worker

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl.inference.harness
Class inference_worker

java.lang.Object
  com.cyc.tool.subl.util.SubLTrampolineFile
      com.cyc.tool.subl.util.SubLTranslatedFile
          com.cyc.cycjava.cycl.inference.harness.inference_worker

All Implemented Interfaces:: CommonSymbols, SubLFile

public final class inference_worker
extends SubLTranslatedFile
extends SubLTranslatedFile

Nested Class Summary

Nested classes/interfaces inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`SubLTranslatedFile.SubL`

Field Summary
`static SubLSymbol`	$asent_of_currently_executing_tactic$
`static SubLSymbol`	$currently_active_problem$
`static SubLSymbol`	$currently_executing_tactic$
`static SubLSymbol`	$disable_link_propagationP$ When non-NIL link propagation is disabled.
`static SubLSymbol`	$eager_proof_validationP$ Whether the Worker tests all newly proofs for well-formedness as soon as they are created.
`static SubLInteger`	`$int80$300`
`static SubLInteger`	`$int96$50`
`static SubLSymbol`	`$kw100$RESIDUAL_TRANSFORMATION`
`static SubLSymbol`	`$kw101$DISJUNCTIVE_ASSUMPTION`
`static SubLSymbol`	`$kw103$EXCEPTED_ASSERTION`
`static SubLSymbol`	`$kw104$ABNORMAL`
`static SubLSymbol`	`$kw109$UNEXAMINED`
`static SubLSymbol`	`$kw111$INTUITIVE`
`static SubLSymbol`	`$kw112$UNDETERMINED`
`static SubLSymbol`	`$kw114$NEW`
`static SubLSymbol`	`$kw115$UNEXAMINED_GOOD`
`static SubLSymbol`	`$kw116$UNEXAMINED_NO_GOOD`
`static SubLSymbol`	`$kw117$EXAMINED`
`static SubLSymbol`	`$kw118$EXAMINED_GOOD`
`static SubLSymbol`	`$kw119$EXAMINED_NO_GOOD`
`static SubLSymbol`	`$kw12$TACTICAL`
`static SubLSymbol`	`$kw120$POSSIBLE_GOOD`
`static SubLSymbol`	`$kw121$PENDING`
`static SubLSymbol`	`$kw122$PENDING_GOOD`
`static SubLSymbol`	`$kw123$PENDING_NO_GOOD`
`static SubLSymbol`	`$kw124$FINISHED`
`static SubLSymbol`	`$kw125$FINISHED_GOOD`
`static SubLSymbol`	`$kw126$FINISHED_NO_GOOD`
`static SubLSymbol`	`$kw127$SUBSTRATEGY_PROBLEM_STATUS_CHANGE`
`static SubLSymbol`	`$kw13$SKIP`
`static SubLSymbol`	`$kw134$POSSIBLE_NO_GOOD`
`static SubLSymbol`	`$kw14$POS`
`static SubLSymbol`	`$kw140$PROBLEM_NO_GOOD`
`static SubLSymbol`	`$kw141$CONJUNCTIVE`
`static SubLSymbol`	`$kw142$CONTENT`
`static SubLSymbol`	`$kw143$SIMPLIFICATION`
`static SubLSymbol`	`$kw144$ANYTHING`
`static SubLSymbol`	`$kw15$NEG`
`static SubLSymbol`	`$kw160$EQUAL`
`static SubLSymbol`	`$kw161$CZER_EQUAL`
`static SubLSymbol`	`$kw166$UNINITIALIZED`
`static SubLSymbol`	`$kw178$DO_HASH_TABLE`
`static SubLSymbol`	`$kw18$NON_DISCARDED`
`static SubLSymbol`	`$kw35$SPLIT`
`static SubLSymbol`	`$kw36$JOIN_ORDERED`
`static SubLSymbol`	`$kw37$UNION`
`static SubLSymbol`	`$kw38$JOIN`
`static SubLSymbol`	`$kw46$REMOVAL`
`static SubLSymbol`	`$kw47$RESTRICTION`
`static SubLSymbol`	`$kw51$TRANSFORMATION`
`static SubLSymbol`	`$kw53$REWRITE`
`static SubLSymbol`	`$kw56$COMPLETE`
`static SubLSymbol`	`$kw57$PREFERRED`
`static SubLSymbol`	`$kw58$GENERALIZED_REMOVAL`
`static SubLSymbol`	`$kw59$POSSIBLE`
`static SubLSymbol`	`$kw60$DISPREFERRED`
`static SubLSymbol`	`$kw61$GROSSLY_DISPREFERRED`
`static SubLSymbol`	`$kw62$DISALLOWED`
`static SubLSymbol`	`$kw64$CONNECTED_CONJUNCTION`
`static SubLSymbol`	`$kw65$STRUCTURAL`
`static SubLSymbol`	`$kw66$LOGICAL`
`static SubLSymbol`	`$kw67$IMPOSSIBLE`
`static SubLSymbol`	`$kw68$STRUCTURAL_CONJUNCTIVE`
`static SubLSymbol`	`$kw70$_MEMOIZED_ITEM_NOT_FOUND_`
`static SubLSymbol`	`$kw71$NONE`
`static SubLSymbol`	`$kw72$MINIMAL`
`static SubLSymbol`	`$kw73$ALL`
`static SubLSymbol`	`$kw74$ARG_TYPE`
`static SubLSymbol`	`$kw81$CIRCULAR`
`static SubLSymbol`	`$kw82$ILL_FORMED`
`static SubLSymbol`	`$kw83$NON_ABDUCIBLE_RULE`
`static SubLSymbol`	`$kw84$MODUS_TOLLENS_WITH_NON_WFF`
`static SubLSymbol`	`$kw85$PROVEN`
`static SubLSymbol`	`$kw86$REJECTED_SUBPROOF`
`static SubLSymbol`	`$kw97$MAX_PROOF_BUBBLING_DEPTH`
`static SubLSymbol`	`$kw98$ANSWER`
`static SubLList`	`$list0`
`static SubLList`	`$list145`
`static SubLList`	`$list158`
`static SubLList`	`$list16`
`static SubLList`	`$list169`
`static SubLList`	`$list170`
`static SubLList`	`$list177`
`static SubLList`	`$list185`
`static SubLList`	`$list23`
`static SubLList`	`$list3`
`static SubLList`	`$list5`
`static SubLList`	`$list6`
`static SubLList`	`$list76`
`static SubLList`	`$list87`
`static SubLList`	`$list92`
`static SubLSymbol`	$max_proof_bubbling_depth$ the depth above which we forcibly halt recursive proof bubbling
`static SubLSymbol`	$mt_of_currently_executing_tactic$
`static SubLSymbol`	$problem_store_prune_reports$ Whether the problem store prune should be verbose.
`static SubLSymbol`	$proof_bubbling_depth$ used as a failsafe to avoid infinite proof bubbling
`static SubLSymbol`	$reconsidering_set_asidesP$ Whether we are currently reconsidering set-asides for some strategy.
`static SubLString`	`$str10$_a_was_not_an__unexamined_problem`
`static SubLString`	`$str102$can_t_handle_bubbling_up_proofs_p`
`static SubLString`	`$str107$generalized_transformation_proof_`
`static SubLString`	`$str108$Invalid_sense__s`
`static SubLString`	`$str11$_a_was__unexamined_but_somehow_go`
`static SubLString`	`$str110$Tried_to_make__a_pending_but_it_s`
`static SubLString`	`$str113$Uninteresting_problem_status_chan`
`static SubLString`	`$str128$Problem__a_attempted_to_change_st`
`static SubLString`	`$str129$new_problem_cannot_become_good_ye`
`static SubLString`	`$str130$Once_a_problem_is_no_good__it_can`
`static SubLString`	`$str131$unknown_problem_status__a`
`static SubLString`	`$str132$problem_status__a_cannot_become_u`
`static SubLString`	`$str133$problem_of_status__a_cannot_be_ex`
`static SubLString`	`$str135$problem_of_status__a_cannot_be_ma`
`static SubLString`	`$str136$problem_of_status__a_cannot_be_pe`
`static SubLString`	`$str137$problem_of_status__a_cannot_be_fi`
`static SubLString`	`$str138$Unexpected_status__s`
`static SubLString`	`$str139$unexpected_link_type__S`
`static SubLString`	`$str157$Time_to_handle__S_propagation`
`static SubLString`	`$str159$Propagating_bogus_proof_spec__A_d`
`static SubLString`	`$str163$__pruned__a_problems____a_____a__`
`static SubLString`	`$str167$Invalid_attempt_to_reuse_memoizat`
`static SubLString`	`$str168$destroying_in_progress_tactic__a`
`static SubLString`	`$str182$_a_was_not_a_problem_p_or_problem`
`static SubLString`	`$str183$__prunables___s__`
`static SubLString`	`$str184$Unexpected_problem_store_object__`
`static SubLString`	`$str19$unexpected_tactic__S`
`static SubLString`	`$str20$Tried_to_recursively_execute__a`
`static SubLString`	`$str21$Tried_to_execute_a_tactic_that_wa`
`static SubLString`	`$str22$unexpected_tactic__s`
`static SubLString`	`$str26$Got_a_literal_level_tactic__s_tha`
`static SubLString`	`$str27$Unexpected_multiple_clause_tactic`
`static SubLString`	`$str28$Unexpected_multiple_literal_tacti`
`static SubLString`	`$str29$Unexpected_structural_multiple_li`
`static SubLString`	`$str30$Unexpected_meta_structural_multip`
`static SubLString`	`$str31$unexpected_connected_conjunction_`
`static SubLString`	`$str32$unexpected_connected_conjunction_`
`static SubLString`	`$str33$unexpected_disjunctive_link__s`
`static SubLString`	`$str34$_s_was_not_a_logical_link_with_un`
`static SubLString`	`$str39$Unexpected_logical_tactic_module_`
`static SubLString`	`$str40$Join_tactics_like__S_do_not_have_`
`static SubLString`	`$str42$_a_is_not_a_CONTENT_LINK_P`
`static SubLString`	`$str44$Unexpected_content_tactic__S`
`static SubLString`	`$str45$Unexpected_removal_tactic__S`
`static SubLString`	`$str63$Unexpected_preference_level__s`
`static SubLString`	`$str75$Unexpected_intermediate_step_vali`
`static SubLString`	`$str77$Didn_t_expect_to_bubble_up_a_proo`
`static SubLString`	`$str78$Unexpected_link_type_for_link__a`
`static SubLString`	`$str89$expected_a_variable_map_to_be_nul`
`static SubLString`	`$str93$Found_a_triplicate_binding_for__s`
`static SubLString`	`$str94$Could_not_find_two_values_in__s_w`
`static SubLSymbol`	`$sym1$CLET`
`static SubLSymbol`	`$sym105$CACHED_INFERENCE_PROOF_NON_EXPLANATORY_SUBPROOFS`
`static SubLSymbol`	`$sym106$GENERALIZED_TRANSFORMATION_PROOF_P`
`static SubLSymbol`	`$sym146$FILTER_PROOF_SPECS_OF_TYPE`
`static SubLSymbol`	`$sym147$PUNLESS`
`static SubLSymbol`	`$sym148$NULL`
`static SubLSymbol`	`$sym149$JOIN_ORDERED_PROOF_SPEC_P`
`static SubLSymbol`	`$sym150$RESIDUAL_TRANSFORMATION_PROOF_SPEC_P`
`static SubLSymbol`	`$sym151$RESTRICTION_PROOF_SPEC_P`
`static SubLSymbol`	`$sym152$SPLIT_PROOF_SPEC_P`
`static SubLSymbol`	`$sym153$JOIN_PROOF_SPEC_P`
`static SubLSymbol`	`$sym154$CONJUNCTIVE_REMOVAL_PROOF_SPEC_P`
`static SubLSymbol`	`$sym155$TRANSFORMATION_PROOF_SPEC_P`
`static SubLSymbol`	`$sym156$UNION_PROOF_SPEC_P`
`static SubLSymbol`	`$sym162$_PROBLEM_STORE_PRUNE_REPORTS_`
`static SubLSymbol`	`$sym164$_`
`static SubLSymbol`	`$sym165$PROBLEM_MIN_DEPTH`
`static SubLSymbol`	`$sym17$STRATEGY_P`
`static SubLSymbol`	`$sym171$_`
`static SubLSymbol`	`$sym172$PROBLEM_LINK_SUID`
`static SubLSymbol`	`$sym173$PROBLEM_SUID`
`static SubLSymbol`	`$sym174$CONJUNCTIVE_REMOVAL_PROOF_P`
`static SubLSymbol`	`$sym175$PROOF_SUID`
`static SubLSymbol`	`$sym176$PROBLEM_HAS_AN_IN_PROGRESS_TACTIC_`
`static SubLSymbol`	`$sym179$PROBLEM_STORE_P`
`static SubLSymbol`	`$sym180$SET_SIZE`
`static SubLSymbol`	`$sym181$PROOF_PRUNABLE_`
`static SubLSymbol`	`$sym186$TACTICALLY_FINISHED_PROBLEM_P`
`static SubLSymbol`	`$sym2$_CURRENTLY_EXECUTING_TACTIC_`
`static SubLSymbol`	`$sym24$_ASENT_OF_CURRENTLY_EXECUTING_TACTIC_`
`static SubLSymbol`	`$sym25$_MT_OF_CURRENTLY_EXECUTING_TACTIC_`
`static SubLSymbol`	`$sym4$_CURRENTLY_ACTIVE_PROBLEM_`
`static SubLSymbol`	`$sym41$STRUCTURAL_PROOF_P`
`static SubLSymbol`	`$sym43$CONTENT_TACTIC_P`
`static SubLSymbol`	`$sym48$CONJUNCTIVE_REMOVAL_TACTIC_P`
`static SubLSymbol`	`$sym49$SPLIT_LINK_P`
`static SubLSymbol`	`$sym50$TRANSFORMATION_TACTIC_P`
`static SubLSymbol`	`$sym52$REWRITE_TACTIC_P`
`static SubLSymbol`	`$sym54$META_REMOVAL_TACTIC_P`
`static SubLSymbol`	`$sym55$STRATEGIC_CONTEXT_P`
`static SubLSymbol`	`$sym69$INTERMEDIATE_PROOF_STEP_VALID_MEMOIZED_`
`static SubLSymbol`	`$sym7$_NEGATION_BY_FAILURE_`
`static SubLSymbol`	`$sym79$PROOF_P`
`static SubLSymbol`	`$sym8$PROBLEM_STORE_NEGATION_BY_FAILURE_`
`static SubLSymbol`	`$sym88$PROBLEM_LINK_TO_GOAL_P`
`static SubLSymbol`	`$sym9$PROBLEM_P`
`static SubLSymbol`	`$sym90$VARIABLE__`
`static SubLSymbol`	`$sym91$VARIABLE_BINDING_VARIABLE`
`static SubLSymbol`	`$sym95$BINDINGS_P`
`static SubLSymbol`	`$sym99$VARIABLE_MAP_P`
`static SubLFile`	`me`
`static java.lang.String`	`myName`

Fields inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`EMPTY_SUBL_OBJECT_ARRAY`

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols
ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Fields inherited from interface com.cyc.tool.subl.jrtl.nativeCode.subLisp.CommonSymbols

ANSWER_TAG, APPEND_KEYWORD, APPEND_STACK_TRACES_TO_ERROR_MESSAGES, AREF, ASSEMBLE_FIXNUMS_TO_INTEGER, ATOM, BIGNUMP, BINARY_KEYWORD, BINDING_TYPE, BOOLEANP, CAAR, CADR, CAND, CAR, CCATCH, CDEC, CDESTRUCTURING_BIND, CDO, CDO_ALL_SYMBOLS, CDO_EXTERNAL_SYMBOLS, CDO_SYMBOLS, CDOHASH, CDOLIST, CDOTIMES, CDR, CHAR, CHAR_E_SYMBOL, CHAR_EQUAL_SYMBOL, CHAR_GREATER_THAN_OR_EQUAL_SYMBOL, CHAR_GREATER_THAN_SYMBOL, CHAR_GT_SYMBOL, CHAR_GTE_SYMBOL, CHAR_LESS_THAN_OR_EQUAL_SYMBOL, CHAR_LESS_THAN_SYMBOL, CHAR_LT_SYMBOL, CHAR_LTE_SYMBOL, CHAR_NE_SYMBOL, CHAR_NOT_EQUAL_SYMBOL, CHARACTERP, CHECK_TYPE, CINC, CLET, CMULTIPLE_VALUE_BIND, CNOT, CONS, CONSP, CONSTANT, COR, CPOP, CPROGV, CPUSH, CPUSHNEW, CREATE_KEYWORD, CSETF, CSETQ, CSOME, CTIME, CUNWIND_PROTECT, CVS_ID, DEBUG_IO, DECLAIM, DECLARE, DEFCONSTANT, DEFINE, DEFLEXICAL, DEFMACRO, DEFPARAMETER, DEFVAR, DIRECTION_KEYWORD, DYNAMIC, EIGHT_INTEGER, EIGHTEEN_INTEGER, ELEMENT_TYPE_KEYWORD, ELEVEN_INTEGER, END_KEYWORD, ENFORCE_MUST, ENFORCE_TYPE, EQ, EQL, EQUAL, EQUALP, ERROR, ERROR_KEYWORD, ERROR_OUTPUT, EVAL, EXTERNAL_FORMAT_KEYWORD, EXTERNAL_KEYWORD, FIF, FIFTEEN_INTEGER, FIRST, FIVE_INTEGER, FIXNUMP, FLOATP, FOUR_INTEGER, FOURTEEN_INTEGER, FUNCTION, FUNCTION_SPEC_P, FUNCTIONP, FUNLESS, FWHEN, GET, GETHASH, GETHASH_WITHOUT_VALUES, GUID_P, HASH_TABLE_ITERATOR_P, HASH_TABLE_P, IDENTITY, IF_DOES_NOT_EXIST_KEYWORD, IF_EXISTS_KEYWORD, IGNORE, INITIALIZATION_TYPE, INITIALIZER, INPUT_KEYWORD, INPUT_STREAM_P, INTEGERP, INTERNAL_KEYWORD, IO_KEYWORD, KEYWORDP, KILL_KEYWORD, LAMBDA_SYMBOL, LEXICAL, LIST, LISTP, LISTS, LOCK_P, LONG_BIGNUM_P, MACRO_ENV, MACRO_FORM, MEDIUM_BIGNUM_P, MEMBER, MINUS_ONE_INTEGER, MULTIPLE_VALUE_LIST, MUST, NCONC, NEW_VERSION_KEYWORD, NIL, NINE_INTEGER, NINETEEN_INTEGER, NREVERSE, NTH, NTH_VALUE, NULL, NULL_INPUT, NULL_OUTPUT, NUM_E_SYMBOL, NUM_GT_SYMBOL, NUM_GTE_SYMBOL, NUM_LT_SYMBOL, NUM_LTE_SYMBOL, NUM_NE_SYMBOL, NUMBERP, ONE_HUNDRED_THIRTY_SEVEN_INTEGER, ONE_HUNDRED_TWENTY_SEVEN_INTEGER, ONE_INTEGER, ONE_THOUSAND_INTEGER, OPTIONAL_SYMBOL, OTHERWISE, OUTPUT_KEYWORD, OUTPUT_STREAM_P, OVERWRITE_KEYWORD, PACKAGEP, PCASE, PCOND, PIF, PROBE_KEYWORD, PROCESS_TO_END, PROCESSP, PROCLAIM, PROGN, PUNLESS, PWHEN, QUERY_IO, QUIT, QUOTE, RENAME_AND_DELETE_KEYWORD, REST_SYMBOL, RET, RET_NIL, RET_T, RETURN_TAG, REVERSE, RW_LOCK_P, SECOND, SEQUENCEP, SEVEN_INTEGER, SEVENTEEN_INTEGER, SHORT_BIGNUM_P, SHOW_STACK_TRACES, SIX_INTEGER, SIXTEEN_INTEGER, SIXTY_FOUR_INTEGER, SORT, SSS, STANDARD_INPUT, STANDARD_OUTPUT, START_KEYWORD, STREAMP, STRING_E_SYMBOL, STRING_EQUAL_SYMBOL, STRING_GREATER_THAN_OR_EQUAL_SYMBOL, STRING_GREATER_THAN_SYMBOL, STRING_GT_SYMBOL, STRING_GTE_SYMBOL, STRING_LESS_THAN_OR_EQUAL_SYMBOL, STRING_LESS_THAN_SYMBOL, STRING_LT_SYMBOL, STRING_LTE_SYMBOL, STRING_NE_SYMBOL, STRING_NOT_EQUAL_SYMBOL, STRINGP, STRUCTURE_P, SUPERSEDE_KEYWORD, SUSPEND_TYPE_CHECKING, SYMBOL_FUNCTION, SYMBOL_VALUE, SYMBOLP, T, TEN_INTEGER, TERMINAL_IO, TEXT_KEYWORD, THIRTEEN_INTEGER, THIRTY_FOUR_INTEGER, THIRTY_THREE_INTEGER, THIRTY_TWO_INTEGER, THREE_INTEGER, TRACE_OUTPUT, TRUE, TWELVE_INTEGER, TWENTY_INTEGER, TWO_HUNDRED_FIFTY_FOUR_INTEGER, TWO_HUNDRED_FORTY_FOUR_INTEGER, TWO_INTEGER, UNDECLARED, UNPROVIDED, VALUES, VECTOR, VECTORP, WITH_ERROR_HANDLER, WITH_STATIC_AREA, WITH_THREAD_PRIVATE_AREA, WITH_WORKING_AREA, WORLD, ZERO_DOUBLE, ZERO_INTEGER

Method Summary
`static SubLObject`	`all_bindings_ground_outP(SubLObject v_bindings)`
`static SubLObject`	`binding_ground_outP(SubLObject binding)`
`static SubLObject`	`bubble_up_proof_from_problem(SubLObject proof, SubLObject problem)`
`static SubLObject`	`bubble_up_proof_to_link_via_mapped_problem(SubLObject proof, SubLObject dependent_link, SubLObject mapped_problem)`
`static SubLObject`	`bubble_up_proof_to_link_via_variable_map(SubLObject proof, SubLObject variable_map, SubLObject dependent_link)` Just having PROOF and DEPENDENT-LINK is not enough, because if DEPENDENT-LINK has two or more supporting problems which are both equal to the supported problem of PROOF, then we couldn't distinguish them without VARIABLE-MAP.
`static SubLObject`	`bubble_up_proof_to_link(SubLObject proof, SubLObject dependent_link)`
`static SubLObject`	`bubble_up_proof(SubLObject proof)`
`static SubLObject`	`canonicalize_proof_bindings(SubLObject proof_bindings)`
`static SubLObject`	`change_and_propagate_problem_status(SubLObject problem, SubLObject new_status, SubLObject consider_deepP, SubLObject strategic_context)`
`static SubLObject`	`compute_strategic_properties_of_problem_tactics(SubLObject problem, SubLObject strategy, SubLObject status)`
`static SubLObject`	`conjunctive_link_p(SubLObject object)`
`static SubLObject`	`conjunctive_proof_subsumes_conjunctive_proof_specP(SubLObject proof, SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`static SubLObject`	`conjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`connected_conjunction_link_p(SubLObject object)`
`static SubLObject`	`connected_conjunction_link_tactic(SubLObject link)`
`static SubLObject`	`connected_conjunction_proof_subsumes_connected_conjunction_proof_specP(SubLObject proof, SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`static SubLObject`	`connected_conjunction_tactic_link(SubLObject tactic)`
`static SubLObject`	`connected_conjunction_tactic_literal_count(SubLObject conjunctive_tactic)`
`static SubLObject`	`connected_conjunction_tactic_p(SubLObject object)`
`static SubLObject`	`consider_closing_answer_link(SubLObject answer_link)`
`static SubLObject`	`consider_pruning_ramifications_of_ignored_strategem(SubLObject strategy, SubLObject strategem)`
`static SubLObject`	`consider_ramifications_of_problem_finished(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`consider_strategic_ramifications_of_executed_tactic(SubLObject strategy, SubLObject tactic)`
`static SubLObject`	`consider_strategic_ramifications_of_possibly_executed_tactic(SubLObject strategy, SubLObject tactic)`
`static SubLObject`	`consider_that_mapped_problem_could_be_irrelevant(SubLObject mapped_problem, SubLObject dependent_link)`
`static SubLObject`	`consider_that_problem_could_be_finished(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`consider_that_problem_could_be_good(SubLObject problem)` Changes PROBLEM's status to a good version of its current status if it has at least one argument link which is good.
`static SubLObject`	`consider_that_problem_could_be_irrelevant_to_inference(SubLObject problem, SubLObject inference)`
`static SubLObject`	`consider_that_problem_could_be_no_good(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`consider_that_problem_could_be_strategically_pending_wrt(SubLObject problem, SubLObject strategy)`
`static SubLObject`	`consider_that_problem_could_be_strategically_pending(SubLObject problem)`
`static SubLObject`	`consider_that_subproofs_may_be_unprocessed(SubLObject new_proof)`
`static SubLObject`	`consider_that_supported_problems_could_be_no_good(SubLObject supporting_problem, SubLObject consider_deepP, SubLObject strategic_context)`
`static SubLObject`	`content_link_hl_module(SubLObject content_link)`
`static SubLObject`	`content_link_p(SubLObject object)`
`static SubLObject`	`content_link_supports(SubLObject content_link)`
`static SubLObject`	`content_proof_hl_module(SubLObject proof)`
`static SubLObject`	`content_proof_p(SubLObject proof)`
`static SubLObject`	`content_tactic_p(SubLObject object)`
`static SubLObject`	`currently_active_problem_store()`
`static SubLObject`	`currently_active_problem()`
`static SubLObject`	`currently_executing_tactic()` Return nil or tactic-p; the current tactic under execution, or NIL if none.
`static SubLObject`	`declare_inference_worker_file()`
`void`	`declareFunctions()` Declares the mapping between functions and symbols for all named functions defined in the file.
`static SubLObject`	`default_compute_strategic_properties_of_tactic(SubLObject strategy, SubLObject tactic)` Depending on what type of tactic TACTIC is, compute its strategic properties wrt STRATEGY.
`static SubLObject`	`default_consider_that_problem_could_be_no_good(SubLObject strategic_context, SubLObject problem, SubLObject consider_deepP, SubLObject consider_transformation_tacticsP)` Changes PROBLEM's status to no-good if it will never have any goal descendants.
`static SubLObject`	`depth_L(SubLObject depth1, SubLObject depth2)`
`static SubLObject`	`determine_new_connected_conjunction_tactics(SubLObject problem, SubLObject dnf_clause)`
`static SubLObject`	`determine_new_tactics_for_dnf_clause(SubLObject problem, SubLObject dnf_clause)`
`static SubLObject`	`determine_new_tactics_for_literal(SubLObject problem, SubLObject contextualized_asent, SubLObject sense)`
`static SubLObject`	`determine_new_tactics_for_multiple_literals(SubLObject problem, SubLObject dnf_clause)`
`static SubLObject`	`determine_new_tactics(SubLObject problem)` Determines the tactics for PROBLEM, adds them to PROBLEM, and sets the status of PROBLEM to :possible.
`static SubLObject`	`determine_strategic_status_wrt(SubLObject problem, SubLObject strategic_context)` Push PROBLEM as far as it can go wrt STRATEGIC-CONTEXT trough the progression of strategic statuses.
`static SubLObject`	`discard_all_impossible_possible_tactics(SubLObject problem)`
`static SubLObject`	`discard_all_other_possible_structural_conjunctive_tactics(SubLObject tactic)` Discards all conjunctive tactics on TACTIC's problem, other than TACTIC.
`static SubLObject`	`discard_all_possible_tactics(SubLObject problem)`
`static SubLObject`	`discard_possible_tactics_int(SubLObject problem, SubLObject completeness, SubLObject preference_level, SubLObject type, SubLObject tactic_to_not_discard, SubLObject productivity)`
`static SubLObject`	`disjunctive_link_p(SubLObject object)`
`static SubLObject`	`disjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`examined_version_of_problem_status(SubLObject status)`
`static SubLObject`	`execute_literal_level_tactic(SubLObject tactic)`
`static SubLObject`	`execute_meta_structural_multiple_literal_tactic(SubLObject tactic)`
`static SubLObject`	`execute_multiple_literal_tactic(SubLObject tactic)`
`static SubLObject`	`execute_structural_multiple_literal_tactic(SubLObject tactic)`
`static SubLObject`	`execute_tactic(SubLObject tactic)`
`static SubLObject`	`find_or_create_problem_from_subclause_spec(SubLObject store, SubLObject contextualized_clause, SubLObject subclause_spec)` Return a problem in STORE whose query is the literals from CONTEXTUALIZED-CLAUSE specified by SUBCLAUSE-SPEC.
`static SubLObject`	`find_or_create_problem_without_subclause_spec(SubLObject store, SubLObject contextualized_clause, SubLObject subclause_spec)` Return a problem in STORE whose query is CONTEXTUALIZED-CLAUSE without the literals specified by SUBCLAUSE-SPEC.
`static SubLObject`	`find_or_create_problem(SubLObject store, SubLObject query, SubLObject complexP)`
`static SubLObject`	`find_or_create_root_problem_and_link(SubLObject inference)`
`static SubLObject`	`find_or_create_root_problem(SubLObject store, SubLObject query)`
`static SubLObject`	`find_problem_int(SubLObject store, SubLObject query, SubLObject complexP)`
`static SubLObject`	`find_proof(SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`static SubLObject`	`finished_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`finished_version_of_problem_status(SubLObject status)`
`static SubLObject`	`generalized_conjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`generalized_structural_tactic_p(SubLObject tactic)`
`static SubLObject`	`good_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`good_version_of_problem_status(SubLObject status)`
`static SubLObject`	`inference_deems_answer_link_should_be_closedP(SubLObject inference, SubLObject answer_link)`
`static SubLObject`	`inference_proof_non_explanatory_subproofs(SubLObject inference, SubLObject proof)`
`static SubLObject`	`init_inference_worker_file()`
`void`	`initializeVariables()` Initializes all global variables and private internal variables for constants defined in the file.
`static SubLObject`	`join_link_could_be_finishedP(SubLObject j_link, SubLObject strategic_context)`
`static SubLObject`	`link_permits_activity_propagationP(SubLObject link, SubLObject supporting_mapped_problem)`
`static SubLObject`	`link_permits_no_good_propagation_to_supported_problemsP(SubLObject link)`
`static SubLObject`	`link_permits_proof_propagationP(SubLObject link, SubLObject supporting_mapped_problem)`
`static SubLObject`	`link_permits_relevance_propagationP(SubLObject link, SubLObject supporting_mapped_problem)`
`static SubLObject`	`literal_level_tactic_p(SubLObject tactic)`
`static SubLObject`	`logical_conjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`logical_disjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`logical_link_p(SubLObject object)`
`static SubLObject`	`logical_link_unique_tactic(SubLObject link)`
`static SubLObject`	`logical_tactic_generalized_removal_completeness(SubLObject logical_tactic, SubLObject strategic_context)`
`static SubLObject`	`logical_tactic_link(SubLObject logical_tactic)`
`static SubLObject`	`logical_tactic_lookahead_problem(SubLObject logical_tactic)`
`static SubLObject`	`logical_tactic_p(SubLObject object)`
`static SubLObject`	`logical_tactic_transformation_allowed_wrt_max_transformation_depthP(SubLObject inference, SubLObject logical_tactic)` Return T iff transformation motivation on LOGICAL-TACTIC is allowed based on the max transformation depth of INFERENCE.
`static SubLObject`	`logical_tactic_with_unique_lookahead_problem_p(SubLObject tactic)`
`static SubLObject`	`make_problem_irrelevant_to_inference(SubLObject inference, SubLObject problem)`
`static SubLObject`	`make_problem_no_good(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context)`
`static SubLObject`	`maybe_make_problem_irrelevant_to_inference(SubLObject inference, SubLObject problem)` Unless PROBLEM is already irrelevant to INFERENCE, notes that PROBLEM is now irrelevant to INFERENCE.
`static SubLObject`	`maybe_possibly_activate_problem(SubLObject strategy, SubLObject problem)` Unless PROBLEM is already active in STRATEGY, notifies STRATEGY that PROBLEM might be newly active in it.
`static SubLObject`	`meta_conjunctive_tactic_p(SubLObject object)`
`static SubLObject`	`meta_structural_tactic_p(SubLObject tactic)`
`static SubLObject`	`ncanonicalize_proof_bindings_int(SubLObject proof_bindings)`
`static SubLObject`	`ncanonicalize_proof_bindings(SubLObject proof_bindings)`
`static SubLObject`	`neutral_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`new_goal_proof(SubLObject goal_link)`
`static SubLObject`	`new_root_answer_link(SubLObject inference, SubLObject mapped_root_problem)` Hooks up the answer link between the root subproblem and the strategy, but intentionally doesn't propagate it yet -- this is part of A-Brain behaviour, not initialization.
`static SubLObject`	`no_good_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`no_good_version_of_problem_status(SubLObject status)`
`static SubLObject`	`note_argument_link_added(SubLObject link)`
`static SubLObject`	`note_goal_link_added(SubLObject link)`
`static SubLObject`	`note_problem_created(SubLObject problem)` Changes PROBLEM's status to :unexamined.
`static SubLObject`	`note_problem_examined(SubLObject problem)`
`static SubLObject`	`note_problem_finished(SubLObject problem, SubLObject strategic_context)` Assumes that strategy activity is propagated first, since it uses that as a criterion for considering no-goodness.
`static SubLObject`	`note_problem_pending(SubLObject problem, SubLObject strategic_context)` Assumes that strategy activity is propagated first, since it uses that as a criterion for considering no-goodness.
`static SubLObject`	`note_problem_possible(SubLObject problem)`
`static SubLObject`	`note_problem_strategically_possible(SubLObject problem, SubLObject strategy)`
`static SubLObject`	`note_tactic_finished(SubLObject tactic)`
`static SubLObject`	`pending_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`pending_version_of_problem_status(SubLObject status)`
`static SubLObject`	`perform_lazy_proof_rejection(SubLObject proof, SubLObject inference)`
`static SubLObject`	`possible_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`possible_version_of_problem_status(SubLObject status)`
`static SubLObject`	`possibly_activate_problem(SubLObject strategy, SubLObject problem)`
`static SubLObject`	`possibly_compute_strategic_properties_of_problem_tactics(SubLObject problem, SubLObject strategy)`
`static SubLObject`	`possibly_compute_strategic_properties_of_tactic(SubLObject tactic, SubLObject strategy)`
`static SubLObject`	`possibly_note_eager_pruning_problem(SubLObject problem)`
`static SubLObject`	`possibly_note_problem_finished(SubLObject problem, SubLObject strategic_context)` Notes that PROBLEM is finished (wrt STRATEGIC-CONTEXT) unless it is already known to be finished (wrt STRATEGIC-CONTEXT).
`static SubLObject`	`possibly_note_problem_pending(SubLObject problem, SubLObject strategic_context)` Notes that PROBLEM is pending (wrt STRATEGIC-CONTEXT) unless it is already known to be pending (wrt STRATEGIC-CONTEXT).
`static SubLObject`	`possibly_note_problem_relevant(SubLObject inference, SubLObject problem)`
`static SubLObject`	`possibly_note_problem_strategically_examined(SubLObject problem, SubLObject strategy)`
`static SubLObject`	`possibly_note_problem_strategically_possible(SubLObject problem, SubLObject strategy)`
`static SubLObject`	`possibly_note_proof_processed(SubLObject proof)`
`static SubLObject`	`possibly_note_tactic_finished(SubLObject tactic)`
`static SubLObject`	`possibly_propagate_answer_link(SubLObject link)`
`static SubLObject`	`possibly_propagate_problem_finished(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`problem_could_be_finishedP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`problem_generalized_removal_completeness(SubLObject problem, SubLObject strategic_context)` Returns the maximal completeness of PROBLEM's generalized removal tactics (wrt STRATEGIC-CONTEXT if provided), even the discarded ones.
`static SubLObject`	`problem_goodP(SubLObject problem)` PROBLEM is deemed good iff it has at least one proof.
`static SubLObject`	`problem_has_been_transformedP(SubLObject problem, SubLObject inference)`
`static SubLObject`	`problem_has_some_open_obviously_neutral_argument_linkP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`problem_has_some_proof_spec_to_propagateP(SubLObject problem)`
`static SubLObject`	`problem_irrelevant_to_inferenceP(SubLObject problem, SubLObject inference)`
`static SubLObject`	`problem_link_could_be_finishedP(SubLObject link, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`problem_link_has_some_open_obviously_neutral_supporting_mapped_problemP(SubLObject link, SubLObject strategic_context)`
`static SubLObject`	`problem_link_no_goodP(SubLObject link, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)` A link is considered no-good if at least one of its supporting problems is no good.
`static SubLObject`	`problem_link_open_and_repropagate_index(SubLObject link, SubLObject index)`
`static SubLObject`	`problem_link_open_and_repropagate_supporting_mapped_problem(SubLObject link, SubLObject supporting_mapped_problem)`
`static SubLObject`	`problem_no_good_ignoring_transformation_tacticsP(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`problem_no_goodP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)` A problem is considered no-good if all of its argument links are no good, and it will never have any more.
`static SubLObject`	`problem_raw_tactical_or_strategic_status(SubLObject problem, SubLObject strategic_context)` If STRATEGIC-CONTEXT is :tactical, returns PROBLEM's status.
`static SubLObject`	`problem_strictly_within_max_proof_depthP(SubLObject inference, SubLObject problem)` Return T iff PROBLEM is strictly within (not at) the stated max proof depth of INFERENCE.
`static SubLObject`	`problem_strictly_within_max_transformation_depthP(SubLObject inference, SubLObject problem)` Return T iff PROBLEM is strictly within (not at) the stated max transformation depth of INFERENCE.
`static SubLObject`	`problem_transformation_allowed_wrt_max_transformation_depthP(SubLObject inference, SubLObject problem)` Return T iff transformation on PROBLEM is allowed based on the max transformation depth of INFERENCE.
`static SubLObject`	`proof_bindings_canonicalP_recursive(SubLObject proof_bindings, SubLObject last_id)`
`static SubLObject`	`proof_bindings_canonicalP(SubLObject proof_bindings)`
`static SubLObject`	`proof_bindings_equalP(SubLObject proof_bindings1, SubLObject proof_bindings2)`
`static SubLObject`	`proof_bindings_from_constituents(SubLObject local_bindings, SubLObject sub_bindings, SubLObject variable_map)` Returns bindings mapping local-vars -> old contents + new contents.
`static SubLObject`	`proof_circular_wrtP(SubLObject proof, SubLObject candidate_circular_proof, SubLObject depth)`
`static SubLObject`	`proof_circularP(SubLObject proof)` PROOF is circular when it contains a very similar proof to itself as one of its subproofs.
`static SubLObject`	`proof_depth_L(SubLObject depth1, SubLObject depth2)`
`static SubLObject`	`proof_non_explanatory_subproofs(SubLObject proof)`
`static SubLObject`	`proof_propagate_non_explananatory_subproofs(SubLObject proof)`
`static SubLObject`	`proof_tree_validP(SubLObject proof)`
`static SubLObject`	`proofs_share_problem_and_bindingsP(SubLObject proof1, SubLObject proof2)`
`static SubLObject`	`propagate_answer_link(SubLObject link)` Does all propagation necessary to handle the addition of the newly created answer link LINK.
`static SubLObject`	`propagate_inference_irrelevance(SubLObject inference, SubLObject link)`
`static SubLObject`	`propagate_inference_relevance(SubLObject link)`
`static SubLObject`	`propagate_min_proof_depth_via_link_wrt_inference(SubLObject link, SubLObject inference)` Propagates proof depth wrt INFERENCE down via LINK.
`static SubLObject`	`propagate_min_proof_depth_via_link(SubLObject link)` Propagates proof depth down via LINK.
`static SubLObject`	`propagate_min_transformation_depth_via_link_wrt_inference(SubLObject link, SubLObject inference)` Propagates transformation depth wrt INFERENCE down via LINK.
`static SubLObject`	`propagate_min_transformation_depth_via_link(SubLObject link)` Propagates transformation depth down via LINK.
`static SubLObject`	`propagate_problem_link(SubLObject link)` Does all propagation necessary to handle the addition of the newly created link LINK.
`static SubLObject`	`propagate_proof_spec_via_answer_link(SubLObject answer_link)`
`static SubLObject`	`propagate_proof_spec(SubLObject link)`
`static SubLObject`	`propagate_proof_to_inference(SubLObject proof, SubLObject inference)`
`static SubLObject`	`propagate_proofs(SubLObject link)`
`static SubLObject`	`propagate_relevance_to_supporting_problem(SubLObject problem, SubLObject supporting_problem)` Propagates inferential relevance from PROBLEM to SUPPORTING-PROBLEM
`static SubLObject`	`propagate_strategy_activity(SubLObject link)`
`static SubLObject`	`propose_new_proof_with_bindings(SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`static SubLObject`	`reject_abnormal_subproofs(SubLObject proof)`
`static SubLObject`	`repropagate_newly_opened_link(SubLObject link, SubLObject mapped_supporting_problem)`
`static SubLObject`	`residual_transformation_proof_subsumes_conjunctive_proof_specP(SubLObject proof, SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`void`	`runTopLevelForms()` Runs all top-level forms in order.
`static SubLObject`	`set_problem_raw_tactical_or_strategic_status(SubLObject problem, SubLObject strategic_context, SubLObject status)` If STRATEGIC-CONTEXT is :tactical, sets PROBLEM's status to STATUS.
`static SubLObject`	`setup_inference_worker_file()`
`static SubLObject`	`single_literal_tactic_p(SubLObject tactic)`
`static SubLObject`	`some_no_good_join_argument_linkP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`some_no_good_join_ordered_argument_linkP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`some_no_good_split_argument_linkP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`
`static SubLObject`	`split_link_could_be_finishedP(SubLObject split_link, SubLObject strategic_context)`
`static SubLObject`	`split_proof_subsumes_split_proof_specP(SubLObject proof, SubLObject link, SubLObject proof_bindings, SubLObject subproofs)`
`static SubLObject`	`strategy_chooses_not_to_examine_tacticP(SubLObject strategy, SubLObject tactic)`
`static SubLObject`	`strategy_compute_strategic_properties_of_problem_tactics(SubLObject strategy, SubLObject problem)`
`static SubLObject`	`strategy_note_problem_finished(SubLObject strategic_context, SubLObject problem)`
`static SubLObject`	`structural_proof_type(SubLObject structural_proof)`
`static SubLObject`	`structural_tactic_p(SubLObject tactic)`
`static SubLObject`	`totally_finished_problem_p(SubLObject problem, SubLObject strategic_context)`
`static SubLObject`	`transformation_depth_L(SubLObject depth1, SubLObject depth2)`
`static SubLObject`	`unify_all_equal_bindings(SubLObject v_bindings)` For each variable in BINDINGS which occurs twice, unify its first and second value and append them to the result, unless they are ((T .
`static SubLObject`	`unsatisfiable_problemP(SubLObject problem, SubLObject consider_deepP, SubLObject strategic_context, SubLObject consider_transformation_tacticsP)`

Methods inherited from class com.cyc.tool.subl.util.SubLTranslatedFile
`extractFunctionNamed`

Methods inherited from class com.cyc.tool.subl.util.SubLTrampolineFile
`checkType, enforceType, extractBinaryFunc, extractCount, extractEnd, extractEndUsingSize, extractPackage, extractStart, extractUnaryFunc, main`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

me

public static final SubLFile me

myName

public static final java.lang.String myName

See Also:: Constant Field Values

$currently_executing_tactic$

public static SubLSymbol $currently_executing_tactic$

$currently_active_problem$

public static SubLSymbol $currently_active_problem$

$asent_of_currently_executing_tactic$

public static SubLSymbol $asent_of_currently_executing_tactic$

$mt_of_currently_executing_tactic$

public static SubLSymbol $mt_of_currently_executing_tactic$

$eager_proof_validationP$

public static SubLSymbol $eager_proof_validationP$

Whether the Worker tests all newly proofs for well-formedness as soon as they are created. This could be turned back to t or investigated further if we find that we end up taking large cartesian products of ill-formed proofs.

$proof_bubbling_depth$

public static SubLSymbol $proof_bubbling_depth$

used as a failsafe to avoid infinite proof bubbling

$max_proof_bubbling_depth$

public static SubLSymbol $max_proof_bubbling_depth$

the depth above which we forcibly halt recursive proof bubbling

$disable_link_propagationP$

public static SubLSymbol $disable_link_propagationP$

When non-NIL link propagation is disabled. This is only useful when serializing in problem stores.

$reconsidering_set_asidesP$

public static SubLSymbol $reconsidering_set_asidesP$

Whether we are currently reconsidering set-asides for some strategy. This is used to allow or preclude certain strategic status changes.

$problem_store_prune_reports$

public static SubLSymbol $problem_store_prune_reports$

Whether the problem store prune should be verbose. Currently only NIL and T are supported.

$list0

public static final SubLList $list0

$sym1$CLET

public static final SubLSymbol $sym1$CLET

$sym2$_CURRENTLY_EXECUTING_TACTIC_

public static final SubLSymbol $sym2$_CURRENTLY_EXECUTING_TACTIC_

$list3

public static final SubLList $list3

$sym4$_CURRENTLY_ACTIVE_PROBLEM_

public static final SubLSymbol $sym4$_CURRENTLY_ACTIVE_PROBLEM_

$list5

public static final SubLList $list5

$list6

public static final SubLList $list6

$sym7$_NEGATION_BY_FAILURE_

public static final SubLSymbol $sym7$_NEGATION_BY_FAILURE_

$sym8$PROBLEM_STORE_NEGATION_BY_FAILURE_

public static final SubLSymbol $sym8$PROBLEM_STORE_NEGATION_BY_FAILURE_

$sym9$PROBLEM_P

public static final SubLSymbol $sym9$PROBLEM_P

$str10$_a_was_not_an__unexamined_problem

public static final SubLString $str10$_a_was_not_an__unexamined_problem

$str11$_a_was__unexamined_but_somehow_go

public static final SubLString $str11$_a_was__unexamined_but_somehow_go

$kw12$TACTICAL

public static final SubLSymbol $kw12$TACTICAL

$kw13$SKIP

public static final SubLSymbol $kw13$SKIP

$kw14$POS

public static final SubLSymbol $kw14$POS

$kw15$NEG

public static final SubLSymbol $kw15$NEG

$list16

public static final SubLList $list16

$sym17$STRATEGY_P

public static final SubLSymbol $sym17$STRATEGY_P

$kw18$NON_DISCARDED

public static final SubLSymbol $kw18$NON_DISCARDED

$str19$unexpected_tactic__S

public static final SubLString $str19$unexpected_tactic__S

$str20$Tried_to_recursively_execute__a

public static final SubLString $str20$Tried_to_recursively_execute__a

$str21$Tried_to_execute_a_tactic_that_wa

public static final SubLString $str21$Tried_to_execute_a_tactic_that_wa

$str22$unexpected_tactic__s

public static final SubLString $str22$unexpected_tactic__s

$list23

public static final SubLList $list23

$sym24$_ASENT_OF_CURRENTLY_EXECUTING_TACTIC_

public static final SubLSymbol $sym24$_ASENT_OF_CURRENTLY_EXECUTING_TACTIC_

$sym25$_MT_OF_CURRENTLY_EXECUTING_TACTIC_

public static final SubLSymbol $sym25$_MT_OF_CURRENTLY_EXECUTING_TACTIC_

$str26$Got_a_literal_level_tactic__s_tha

public static final SubLString $str26$Got_a_literal_level_tactic__s_tha

$str27$Unexpected_multiple_clause_tactic

public static final SubLString $str27$Unexpected_multiple_clause_tactic

$str28$Unexpected_multiple_literal_tacti

public static final SubLString $str28$Unexpected_multiple_literal_tacti

$str29$Unexpected_structural_multiple_li

public static final SubLString $str29$Unexpected_structural_multiple_li

$str30$Unexpected_meta_structural_multip

public static final SubLString $str30$Unexpected_meta_structural_multip

$str31$unexpected_connected_conjunction_

public static final SubLString $str31$unexpected_connected_conjunction_

$str32$unexpected_connected_conjunction_

public static final SubLString $str32$unexpected_connected_conjunction_

$str33$unexpected_disjunctive_link__s

public static final SubLString $str33$unexpected_disjunctive_link__s

$str34$_s_was_not_a_logical_link_with_un

public static final SubLString $str34$_s_was_not_a_logical_link_with_un

$kw35$SPLIT

public static final SubLSymbol $kw35$SPLIT

$kw36$JOIN_ORDERED

public static final SubLSymbol $kw36$JOIN_ORDERED

$kw37$UNION

public static final SubLSymbol $kw37$UNION

$kw38$JOIN

public static final SubLSymbol $kw38$JOIN

$str39$Unexpected_logical_tactic_module_

public static final SubLString $str39$Unexpected_logical_tactic_module_

$str40$Join_tactics_like__S_do_not_have_

public static final SubLString $str40$Join_tactics_like__S_do_not_have_

$sym41$STRUCTURAL_PROOF_P

public static final SubLSymbol $sym41$STRUCTURAL_PROOF_P

$str42$_a_is_not_a_CONTENT_LINK_P

public static final SubLString $str42$_a_is_not_a_CONTENT_LINK_P

$sym43$CONTENT_TACTIC_P

public static final SubLSymbol $sym43$CONTENT_TACTIC_P

$str44$Unexpected_content_tactic__S

public static final SubLString $str44$Unexpected_content_tactic__S

$str45$Unexpected_removal_tactic__S

public static final SubLString $str45$Unexpected_removal_tactic__S

$kw46$REMOVAL

public static final SubLSymbol $kw46$REMOVAL

$kw47$RESTRICTION

public static final SubLSymbol $kw47$RESTRICTION

$sym48$CONJUNCTIVE_REMOVAL_TACTIC_P

public static final SubLSymbol $sym48$CONJUNCTIVE_REMOVAL_TACTIC_P

$sym49$SPLIT_LINK_P

public static final SubLSymbol $sym49$SPLIT_LINK_P

$sym50$TRANSFORMATION_TACTIC_P

public static final SubLSymbol $sym50$TRANSFORMATION_TACTIC_P

$kw51$TRANSFORMATION

public static final SubLSymbol $kw51$TRANSFORMATION

$sym52$REWRITE_TACTIC_P

public static final SubLSymbol $sym52$REWRITE_TACTIC_P

$kw53$REWRITE

public static final SubLSymbol $kw53$REWRITE

$sym54$META_REMOVAL_TACTIC_P

public static final SubLSymbol $sym54$META_REMOVAL_TACTIC_P

$sym55$STRATEGIC_CONTEXT_P

public static final SubLSymbol $sym55$STRATEGIC_CONTEXT_P

$kw56$COMPLETE

public static final SubLSymbol $kw56$COMPLETE

$kw57$PREFERRED

public static final SubLSymbol $kw57$PREFERRED

$kw58$GENERALIZED_REMOVAL

public static final SubLSymbol $kw58$GENERALIZED_REMOVAL

$kw59$POSSIBLE

public static final SubLSymbol $kw59$POSSIBLE

$kw60$DISPREFERRED

public static final SubLSymbol $kw60$DISPREFERRED

$kw61$GROSSLY_DISPREFERRED

public static final SubLSymbol $kw61$GROSSLY_DISPREFERRED

$kw62$DISALLOWED

public static final SubLSymbol $kw62$DISALLOWED

$str63$Unexpected_preference_level__s

public static final SubLString $str63$Unexpected_preference_level__s

$kw64$CONNECTED_CONJUNCTION

public static final SubLSymbol $kw64$CONNECTED_CONJUNCTION

$kw65$STRUCTURAL

public static final SubLSymbol $kw65$STRUCTURAL

$kw66$LOGICAL

public static final SubLSymbol $kw66$LOGICAL

$kw67$IMPOSSIBLE

public static final SubLSymbol $kw67$IMPOSSIBLE

$kw68$STRUCTURAL_CONJUNCTIVE

public static final SubLSymbol $kw68$STRUCTURAL_CONJUNCTIVE

$sym69$INTERMEDIATE_PROOF_STEP_VALID_MEMOIZED_

public static final SubLSymbol $sym69$INTERMEDIATE_PROOF_STEP_VALID_MEMOIZED_

$kw70$_MEMOIZED_ITEM_NOT_FOUND_

public static final SubLSymbol $kw70$_MEMOIZED_ITEM_NOT_FOUND_

$kw71$NONE

public static final SubLSymbol $kw71$NONE

$kw72$MINIMAL

public static final SubLSymbol $kw72$MINIMAL

$kw73$ALL

public static final SubLSymbol $kw73$ALL

$kw74$ARG_TYPE

public static final SubLSymbol $kw74$ARG_TYPE

$str75$Unexpected_intermediate_step_vali

public static final SubLString $str75$Unexpected_intermediate_step_vali

$list76

public static final SubLList $list76

$str77$Didn_t_expect_to_bubble_up_a_proo

public static final SubLString $str77$Didn_t_expect_to_bubble_up_a_proo

$str78$Unexpected_link_type_for_link__a

public static final SubLString $str78$Unexpected_link_type_for_link__a

$sym79$PROOF_P

public static final SubLSymbol $sym79$PROOF_P

$int80$300

public static final SubLInteger $int80$300

$kw81$CIRCULAR

public static final SubLSymbol $kw81$CIRCULAR

$kw82$ILL_FORMED

public static final SubLSymbol $kw82$ILL_FORMED

$kw83$NON_ABDUCIBLE_RULE

public static final SubLSymbol $kw83$NON_ABDUCIBLE_RULE

$kw84$MODUS_TOLLENS_WITH_NON_WFF

public static final SubLSymbol $kw84$MODUS_TOLLENS_WITH_NON_WFF

$kw85$PROVEN

public static final SubLSymbol $kw85$PROVEN

$kw86$REJECTED_SUBPROOF

public static final SubLSymbol $kw86$REJECTED_SUBPROOF

$list87

public static final SubLList $list87

$sym88$PROBLEM_LINK_TO_GOAL_P

public static final SubLSymbol $sym88$PROBLEM_LINK_TO_GOAL_P

$str89$expected_a_variable_map_to_be_nul

public static final SubLString $str89$expected_a_variable_map_to_be_nul

$sym90$VARIABLE__

public static final SubLSymbol $sym90$VARIABLE__

$sym91$VARIABLE_BINDING_VARIABLE

public static final SubLSymbol $sym91$VARIABLE_BINDING_VARIABLE

$list92

public static final SubLList $list92

$str93$Found_a_triplicate_binding_for__s

public static final SubLString $str93$Found_a_triplicate_binding_for__s

$str94$Could_not_find_two_values_in__s_w

public static final SubLString $str94$Could_not_find_two_values_in__s_w

$sym95$BINDINGS_P

public static final SubLSymbol $sym95$BINDINGS_P

$int96$50

public static final SubLInteger $int96$50

$kw97$MAX_PROOF_BUBBLING_DEPTH

public static final SubLSymbol $kw97$MAX_PROOF_BUBBLING_DEPTH

$kw98$ANSWER

public static final SubLSymbol $kw98$ANSWER

$sym99$VARIABLE_MAP_P

public static final SubLSymbol $sym99$VARIABLE_MAP_P

$kw100$RESIDUAL_TRANSFORMATION

public static final SubLSymbol $kw100$RESIDUAL_TRANSFORMATION

$kw101$DISJUNCTIVE_ASSUMPTION

public static final SubLSymbol $kw101$DISJUNCTIVE_ASSUMPTION

$str102$can_t_handle_bubbling_up_proofs_p

public static final SubLString $str102$can_t_handle_bubbling_up_proofs_p

$kw103$EXCEPTED_ASSERTION

public static final SubLSymbol $kw103$EXCEPTED_ASSERTION

$kw104$ABNORMAL

public static final SubLSymbol $kw104$ABNORMAL

$sym105$CACHED_INFERENCE_PROOF_NON_EXPLANATORY_SUBPROOFS

public static final SubLSymbol $sym105$CACHED_INFERENCE_PROOF_NON_EXPLANATORY_SUBPROOFS

$sym106$GENERALIZED_TRANSFORMATION_PROOF_P

public static final SubLSymbol $sym106$GENERALIZED_TRANSFORMATION_PROOF_P

$str107$generalized_transformation_proof_

public static final SubLString $str107$generalized_transformation_proof_

$str108$Invalid_sense__s

public static final SubLString $str108$Invalid_sense__s

$kw109$UNEXAMINED

public static final SubLSymbol $kw109$UNEXAMINED

$str110$Tried_to_make__a_pending_but_it_s

public static final SubLString $str110$Tried_to_make__a_pending_but_it_s

$kw111$INTUITIVE

public static final SubLSymbol $kw111$INTUITIVE

$kw112$UNDETERMINED

public static final SubLSymbol $kw112$UNDETERMINED

$str113$Uninteresting_problem_status_chan

public static final SubLString $str113$Uninteresting_problem_status_chan

$kw114$NEW

public static final SubLSymbol $kw114$NEW

$kw115$UNEXAMINED_GOOD

public static final SubLSymbol $kw115$UNEXAMINED_GOOD

$kw116$UNEXAMINED_NO_GOOD

public static final SubLSymbol $kw116$UNEXAMINED_NO_GOOD

$kw117$EXAMINED

public static final SubLSymbol $kw117$EXAMINED

$kw118$EXAMINED_GOOD

public static final SubLSymbol $kw118$EXAMINED_GOOD

$kw119$EXAMINED_NO_GOOD

public static final SubLSymbol $kw119$EXAMINED_NO_GOOD

$kw120$POSSIBLE_GOOD

public static final SubLSymbol $kw120$POSSIBLE_GOOD

$kw121$PENDING

public static final SubLSymbol $kw121$PENDING

$kw122$PENDING_GOOD

public static final SubLSymbol $kw122$PENDING_GOOD

$kw123$PENDING_NO_GOOD

public static final SubLSymbol $kw123$PENDING_NO_GOOD

$kw124$FINISHED

public static final SubLSymbol $kw124$FINISHED

$kw125$FINISHED_GOOD

public static final SubLSymbol $kw125$FINISHED_GOOD

$kw126$FINISHED_NO_GOOD

public static final SubLSymbol $kw126$FINISHED_NO_GOOD

$kw127$SUBSTRATEGY_PROBLEM_STATUS_CHANGE

public static final SubLSymbol $kw127$SUBSTRATEGY_PROBLEM_STATUS_CHANGE

$str128$Problem__a_attempted_to_change_st

public static final SubLString $str128$Problem__a_attempted_to_change_st

$str129$new_problem_cannot_become_good_ye

public static final SubLString $str129$new_problem_cannot_become_good_ye

$str130$Once_a_problem_is_no_good__it_can

public static final SubLString $str130$Once_a_problem_is_no_good__it_can

$str131$unknown_problem_status__a

public static final SubLString $str131$unknown_problem_status__a

$str132$problem_status__a_cannot_become_u

public static final SubLString $str132$problem_status__a_cannot_become_u

$str133$problem_of_status__a_cannot_be_ex

public static final SubLString $str133$problem_of_status__a_cannot_be_ex

$kw134$POSSIBLE_NO_GOOD

public static final SubLSymbol $kw134$POSSIBLE_NO_GOOD

$str135$problem_of_status__a_cannot_be_ma

public static final SubLString $str135$problem_of_status__a_cannot_be_ma

$str136$problem_of_status__a_cannot_be_pe

public static final SubLString $str136$problem_of_status__a_cannot_be_pe

$str137$problem_of_status__a_cannot_be_fi

public static final SubLString $str137$problem_of_status__a_cannot_be_fi

$str138$Unexpected_status__s

public static final SubLString $str138$Unexpected_status__s

$str139$unexpected_link_type__S

public static final SubLString $str139$unexpected_link_type__S

$kw140$PROBLEM_NO_GOOD

public static final SubLSymbol $kw140$PROBLEM_NO_GOOD

$kw141$CONJUNCTIVE

public static final SubLSymbol $kw141$CONJUNCTIVE

$kw142$CONTENT

public static final SubLSymbol $kw142$CONTENT

$kw143$SIMPLIFICATION

public static final SubLSymbol $kw143$SIMPLIFICATION

$kw144$ANYTHING

public static final SubLSymbol $kw144$ANYTHING

$list145

public static final SubLList $list145

$sym146$FILTER_PROOF_SPECS_OF_TYPE

public static final SubLSymbol $sym146$FILTER_PROOF_SPECS_OF_TYPE

$sym147$PUNLESS

public static final SubLSymbol $sym147$PUNLESS

$sym148$NULL

public static final SubLSymbol $sym148$NULL

$sym149$JOIN_ORDERED_PROOF_SPEC_P

public static final SubLSymbol $sym149$JOIN_ORDERED_PROOF_SPEC_P

$sym150$RESIDUAL_TRANSFORMATION_PROOF_SPEC_P

public static final SubLSymbol $sym150$RESIDUAL_TRANSFORMATION_PROOF_SPEC_P

$sym151$RESTRICTION_PROOF_SPEC_P

public static final SubLSymbol $sym151$RESTRICTION_PROOF_SPEC_P

$sym152$SPLIT_PROOF_SPEC_P

public static final SubLSymbol $sym152$SPLIT_PROOF_SPEC_P

$sym153$JOIN_PROOF_SPEC_P

public static final SubLSymbol $sym153$JOIN_PROOF_SPEC_P

$sym154$CONJUNCTIVE_REMOVAL_PROOF_SPEC_P

public static final SubLSymbol $sym154$CONJUNCTIVE_REMOVAL_PROOF_SPEC_P

$sym155$TRANSFORMATION_PROOF_SPEC_P

public static final SubLSymbol $sym155$TRANSFORMATION_PROOF_SPEC_P

$sym156$UNION_PROOF_SPEC_P

public static final SubLSymbol $sym156$UNION_PROOF_SPEC_P

$str157$Time_to_handle__S_propagation

public static final SubLString $str157$Time_to_handle__S_propagation

$list158

public static final SubLList $list158

$str159$Propagating_bogus_proof_spec__A_d

public static final SubLString $str159$Propagating_bogus_proof_spec__A_d

$kw160$EQUAL

public static final SubLSymbol $kw160$EQUAL

$kw161$CZER_EQUAL

public static final SubLSymbol $kw161$CZER_EQUAL

$sym162$_PROBLEM_STORE_PRUNE_REPORTS_

public static final SubLSymbol $sym162$_PROBLEM_STORE_PRUNE_REPORTS_

$str163$pruneda_problems__a_a

public static final SubLString $str163$__pruned__a_problems____a_____a__

$sym164$_

public static final SubLSymbol $sym164$_

$sym165$PROBLEM_MIN_DEPTH

public static final SubLSymbol $sym165$PROBLEM_MIN_DEPTH

$kw166$UNINITIALIZED

public static final SubLSymbol $kw166$UNINITIALIZED

$str167$Invalid_attempt_to_reuse_memoizat

public static final SubLString $str167$Invalid_attempt_to_reuse_memoizat

$str168$destroying_in_progress_tactic__a

public static final SubLString $str168$destroying_in_progress_tactic__a

$list169

public static final SubLList $list169

$list170

public static final SubLList $list170

$sym171$_

public static final SubLSymbol $sym171$_

$sym172$PROBLEM_LINK_SUID

public static final SubLSymbol $sym172$PROBLEM_LINK_SUID

$sym173$PROBLEM_SUID

public static final SubLSymbol $sym173$PROBLEM_SUID

$sym174$CONJUNCTIVE_REMOVAL_PROOF_P

public static final SubLSymbol $sym174$CONJUNCTIVE_REMOVAL_PROOF_P

$sym175$PROOF_SUID

public static final SubLSymbol $sym175$PROOF_SUID

$sym176$PROBLEM_HAS_AN_IN_PROGRESS_TACTIC_

public static final SubLSymbol $sym176$PROBLEM_HAS_AN_IN_PROGRESS_TACTIC_

$list177

public static final SubLList $list177

$kw178$DO_HASH_TABLE

public static final SubLSymbol $kw178$DO_HASH_TABLE

$sym179$PROBLEM_STORE_P

public static final SubLSymbol $sym179$PROBLEM_STORE_P

$sym180$SET_SIZE

public static final SubLSymbol $sym180$SET_SIZE

$sym181$PROOF_PRUNABLE_

public static final SubLSymbol $sym181$PROOF_PRUNABLE_

$str182$_a_was_not_a_problem_p_or_problem

public static final SubLString $str182$_a_was_not_a_problem_p_or_problem

$str183$prunables_s__

public static final SubLString $str183$__prunables___s__

$str184$Unexpected_problem_store_object__

public static final SubLString $str184$Unexpected_problem_store_object__

$list185

public static final SubLList $list185

$sym186$TACTICALLY_FINISHED_PROBLEM_P

public static final SubLSymbol $sym186$TACTICALLY_FINISHED_PROBLEM_P

Method Detail

currently_executing_tactic

public static final SubLObject currently_executing_tactic()

Return nil or tactic-p; the current tactic under execution, or NIL if none.

currently_active_problem

public static final SubLObject currently_active_problem()

Returns:: nil or problem-p; the problem of the current tactic under execution, or the problem whose tactics are being determined, or NIL if none.

currently_active_problem_store

public static final SubLObject currently_active_problem_store()

Returns:: nil or problem-store-p; the problem-store of the currently active problem, or NIL if none.

determine_new_tactics

public static final SubLObject determine_new_tactics(SubLObject problem)

Determines the tactics for PROBLEM, adds them to PROBLEM, and sets the status of PROBLEM to :possible.

determine_new_tactics_for_dnf_clause

public static final SubLObject determine_new_tactics_for_dnf_clause(SubLObject problem,
                                                                    SubLObject dnf_clause)

determine_new_tactics_for_multiple_literals

public static final SubLObject determine_new_tactics_for_multiple_literals(SubLObject problem,
                                                                           SubLObject dnf_clause)

determine_new_connected_conjunction_tactics

public static final SubLObject determine_new_connected_conjunction_tactics(SubLObject problem,
                                                                           SubLObject dnf_clause)

determine_new_tactics_for_literal

public static final SubLObject determine_new_tactics_for_literal(SubLObject problem,
                                                                 SubLObject contextualized_asent,
                                                                 SubLObject sense)

possibly_compute_strategic_properties_of_problem_tactics

public static final SubLObject possibly_compute_strategic_properties_of_problem_tactics(SubLObject problem,
                                                                                        SubLObject strategy)

strategy_compute_strategic_properties_of_problem_tactics

public static final SubLObject strategy_compute_strategic_properties_of_problem_tactics(SubLObject strategy,
                                                                                        SubLObject problem)

compute_strategic_properties_of_problem_tactics

public static final SubLObject compute_strategic_properties_of_problem_tactics(SubLObject problem,
                                                                               SubLObject strategy,
                                                                               SubLObject status)

possibly_compute_strategic_properties_of_tactic

public static final SubLObject possibly_compute_strategic_properties_of_tactic(SubLObject tactic,
                                                                               SubLObject strategy)

strategy_chooses_not_to_examine_tacticP

public static final SubLObject strategy_chooses_not_to_examine_tacticP(SubLObject strategy,
                                                                       SubLObject tactic)

default_compute_strategic_properties_of_tactic

public static final SubLObject default_compute_strategic_properties_of_tactic(SubLObject strategy,
                                                                              SubLObject tactic)

Depending on what type of tactic TACTIC is, compute its strategic properties wrt STRATEGY.

Returns:: booleanp; whether to note that the tactic is strategically possible

execute_tactic

public static final SubLObject execute_tactic(SubLObject tactic)

possibly_note_tactic_finished

public static final SubLObject possibly_note_tactic_finished(SubLObject tactic)

single_literal_tactic_p

public static final SubLObject single_literal_tactic_p(SubLObject tactic)

execute_literal_level_tactic

public static final SubLObject execute_literal_level_tactic(SubLObject tactic)

literal_level_tactic_p

public static final SubLObject literal_level_tactic_p(SubLObject tactic)

execute_multiple_literal_tactic

public static final SubLObject execute_multiple_literal_tactic(SubLObject tactic)

execute_structural_multiple_literal_tactic

public static final SubLObject execute_structural_multiple_literal_tactic(SubLObject tactic)

execute_meta_structural_multiple_literal_tactic

public static final SubLObject execute_meta_structural_multiple_literal_tactic(SubLObject tactic)

connected_conjunction_link_p

public static final SubLObject connected_conjunction_link_p(SubLObject object)

connected_conjunction_tactic_p

public static final SubLObject connected_conjunction_tactic_p(SubLObject object)

connected_conjunction_link_tactic

public static final SubLObject connected_conjunction_link_tactic(SubLObject link)

Returns:: connected-conjunction-tactic-p

connected_conjunction_tactic_link

public static final SubLObject connected_conjunction_tactic_link(SubLObject tactic)

Returns:: connected-conjunction-tactic-p

conjunctive_link_p

public static final SubLObject conjunctive_link_p(SubLObject object)

logical_conjunctive_tactic_p

public static final SubLObject logical_conjunctive_tactic_p(SubLObject object)

conjunctive_tactic_p

public static final SubLObject conjunctive_tactic_p(SubLObject object)

meta_conjunctive_tactic_p

public static final SubLObject meta_conjunctive_tactic_p(SubLObject object)

generalized_conjunctive_tactic_p

public static final SubLObject generalized_conjunctive_tactic_p(SubLObject object)

connected_conjunction_tactic_literal_count

public static final SubLObject connected_conjunction_tactic_literal_count(SubLObject conjunctive_tactic)

disjunctive_link_p

public static final SubLObject disjunctive_link_p(SubLObject object)

logical_disjunctive_tactic_p

public static final SubLObject logical_disjunctive_tactic_p(SubLObject object)

disjunctive_tactic_p

public static final SubLObject disjunctive_tactic_p(SubLObject object)

logical_link_p

public static final SubLObject logical_link_p(SubLObject object)

logical_tactic_p

public static final SubLObject logical_tactic_p(SubLObject object)

logical_tactic_with_unique_lookahead_problem_p

public static final SubLObject logical_tactic_with_unique_lookahead_problem_p(SubLObject tactic)

logical_link_unique_tactic

public static final SubLObject logical_link_unique_tactic(SubLObject link)

logical_tactic_link

public static final SubLObject logical_tactic_link(SubLObject logical_tactic)

logical_tactic_lookahead_problem

public static final SubLObject logical_tactic_lookahead_problem(SubLObject logical_tactic)

structural_tactic_p

public static final SubLObject structural_tactic_p(SubLObject tactic)

meta_structural_tactic_p

public static final SubLObject meta_structural_tactic_p(SubLObject tactic)

generalized_structural_tactic_p

public static final SubLObject generalized_structural_tactic_p(SubLObject tactic)

structural_proof_type

public static final SubLObject structural_proof_type(SubLObject structural_proof)

content_link_p

public static final SubLObject content_link_p(SubLObject object)

content_tactic_p

public static final SubLObject content_tactic_p(SubLObject object)

content_proof_p

public static final SubLObject content_proof_p(SubLObject proof)

content_link_supports

public static final SubLObject content_link_supports(SubLObject content_link)

content_link_hl_module

public static final SubLObject content_link_hl_module(SubLObject content_link)

content_proof_hl_module

public static final SubLObject content_proof_hl_module(SubLObject proof)

logical_tactic_generalized_removal_completeness

public static final SubLObject logical_tactic_generalized_removal_completeness(SubLObject logical_tactic,
                                                                               SubLObject strategic_context)

problem_generalized_removal_completeness

public static final SubLObject problem_generalized_removal_completeness(SubLObject problem,
                                                                        SubLObject strategic_context)

Returns the maximal completeness of PROBLEM's generalized removal tactics (wrt STRATEGIC-CONTEXT if provided), even the discarded ones.

discard_all_other_possible_structural_conjunctive_tactics

public static final SubLObject discard_all_other_possible_structural_conjunctive_tactics(SubLObject tactic)

Discards all conjunctive tactics on TACTIC's problem, other than TACTIC. This is used when the conjunctive tactic TACTIC is known to be complete and has been selected by the strategy, so we can discard all others because they will be subsumed by TACTIC.

propose_new_proof_with_bindings

public static final SubLObject propose_new_proof_with_bindings(SubLObject link,
                                                               SubLObject proof_bindings,
                                                               SubLObject subproofs)

Parameters:: PROOF-BINDINGS; - LINK's supported problem vars -> content
Returns:: 0 nil or proof-p returns NIL iff the proposed proof was semantically invalid wrt the intermediate-step-validation-level

proof_propagate_non_explananatory_subproofs

public static final SubLObject proof_propagate_non_explananatory_subproofs(SubLObject proof)

proof_circularP

public static final SubLObject proof_circularP(SubLObject proof)

PROOF is circular when it contains a very similar proof to itself as one of its subproofs. 'Very similar' means that it has the same problem and the same proof-bindings. Eventually we should extend this to be having the same proven query, but currently we don't have an efficient way to do that.

proof_circular_wrtP

public static final SubLObject proof_circular_wrtP(SubLObject proof,
                                                   SubLObject candidate_circular_proof,
                                                   SubLObject depth)

proofs_share_problem_and_bindingsP

public static final SubLObject proofs_share_problem_and_bindingsP(SubLObject proof1,
                                                                  SubLObject proof2)

possibly_note_proof_processed

public static final SubLObject possibly_note_proof_processed(SubLObject proof)

consider_that_subproofs_may_be_unprocessed

public static final SubLObject consider_that_subproofs_may_be_unprocessed(SubLObject new_proof)

find_proof

public static final SubLObject find_proof(SubLObject link,
                                          SubLObject proof_bindings,
                                          SubLObject subproofs)

Parameters:: PROOF-BINDINGS; - SUPPORTED-PROBLEM's vars -> content
Returns:: nil or proof-p

conjunctive_proof_subsumes_conjunctive_proof_specP

public static final SubLObject conjunctive_proof_subsumes_conjunctive_proof_specP(SubLObject proof,
                                                                                  SubLObject link,
                                                                                  SubLObject proof_bindings,
                                                                                  SubLObject subproofs)

connected_conjunction_proof_subsumes_connected_conjunction_proof_specP

public static final SubLObject connected_conjunction_proof_subsumes_connected_conjunction_proof_specP(SubLObject proof,
                                                                                                      SubLObject link,
                                                                                                      SubLObject proof_bindings,
                                                                                                      SubLObject subproofs)

split_proof_subsumes_split_proof_specP

public static final SubLObject split_proof_subsumes_split_proof_specP(SubLObject proof,
                                                                      SubLObject link,
                                                                      SubLObject proof_bindings,
                                                                      SubLObject subproofs)

residual_transformation_proof_subsumes_conjunctive_proof_specP

public static final SubLObject residual_transformation_proof_subsumes_conjunctive_proof_specP(SubLObject proof,
                                                                                              SubLObject link,
                                                                                              SubLObject proof_bindings,
                                                                                              SubLObject subproofs)

new_goal_proof

public static final SubLObject new_goal_proof(SubLObject goal_link)

Returns:: 0 proof-p

proof_bindings_from_constituents

public static final SubLObject proof_bindings_from_constituents(SubLObject local_bindings,
                                                                SubLObject sub_bindings,
                                                                SubLObject variable_map)

Returns bindings mapping local-vars -> old contents + new contents.

Parameters:: LOCAL-BINDINGS; - local vars -> new contents (or other local unbound), i.e. the bindings established in this exact proof that is being constructed.; SUB-BINDINGS; - subproof-vars -> old contents, i.e. the bindings established by the subproof (recursively).; VARIABLE-MAP; - subproof-vars -> local-vars, i.e. the mapping between the variables in the subproof and the local variables.

ncanonicalize_proof_bindings_int

public static final SubLObject ncanonicalize_proof_bindings_int(SubLObject proof_bindings)

ncanonicalize_proof_bindings

public static final SubLObject ncanonicalize_proof_bindings(SubLObject proof_bindings)

canonicalize_proof_bindings

public static final SubLObject canonicalize_proof_bindings(SubLObject proof_bindings)

proof_bindings_canonicalP

public static final SubLObject proof_bindings_canonicalP(SubLObject proof_bindings)

proof_bindings_canonicalP_recursive

public static final SubLObject proof_bindings_canonicalP_recursive(SubLObject proof_bindings,
                                                                   SubLObject last_id)

proof_bindings_equalP

public static final SubLObject proof_bindings_equalP(SubLObject proof_bindings1,
                                                     SubLObject proof_bindings2)

unify_all_equal_bindings

public static final SubLObject unify_all_equal_bindings(SubLObject v_bindings)

For each variable in BINDINGS which occurs twice, unify its first and second value and append them to the result, unless they are ((T . T))

all_bindings_ground_outP

public static final SubLObject all_bindings_ground_outP(SubLObject v_bindings)

Returns:: boolean; t iff all values in BINDINGS are fully bound

binding_ground_outP

public static final SubLObject binding_ground_outP(SubLObject binding)

bubble_up_proof

public static final SubLObject bubble_up_proof(SubLObject proof)

bubble_up_proof_from_problem

public static final SubLObject bubble_up_proof_from_problem(SubLObject proof,
                                                            SubLObject problem)

bubble_up_proof_to_link

public static final SubLObject bubble_up_proof_to_link(SubLObject proof,
                                                       SubLObject dependent_link)

bubble_up_proof_to_link_via_mapped_problem

public static final SubLObject bubble_up_proof_to_link_via_mapped_problem(SubLObject proof,
                                                                          SubLObject dependent_link,
                                                                          SubLObject mapped_problem)

bubble_up_proof_to_link_via_variable_map

public static final SubLObject bubble_up_proof_to_link_via_variable_map(SubLObject proof,
                                                                        SubLObject variable_map,
                                                                        SubLObject dependent_link)

Just having PROOF and DEPENDENT-LINK is not enough, because if DEPENDENT-LINK has two or more supporting problems which are both equal to the supported problem of PROOF, then we couldn't distinguish them without VARIABLE-MAP.

perform_lazy_proof_rejection

public static final SubLObject perform_lazy_proof_rejection(SubLObject proof,
                                                            SubLObject inference)

reject_abnormal_subproofs

public static final SubLObject reject_abnormal_subproofs(SubLObject proof)

inference_proof_non_explanatory_subproofs

public static final SubLObject inference_proof_non_explanatory_subproofs(SubLObject inference,
                                                                         SubLObject proof)

proof_non_explanatory_subproofs

public static final SubLObject proof_non_explanatory_subproofs(SubLObject proof)

note_tactic_finished

public static final SubLObject note_tactic_finished(SubLObject tactic)

consider_strategic_ramifications_of_possibly_executed_tactic

public static final SubLObject consider_strategic_ramifications_of_possibly_executed_tactic(SubLObject strategy,
                                                                                            SubLObject tactic)

consider_strategic_ramifications_of_executed_tactic

public static final SubLObject consider_strategic_ramifications_of_executed_tactic(SubLObject strategy,
                                                                                   SubLObject tactic)

note_problem_created

public static final SubLObject note_problem_created(SubLObject problem)

Changes PROBLEM's status to :unexamined.

possibly_activate_problem

public static final SubLObject possibly_activate_problem(SubLObject strategy,
                                                         SubLObject problem)

determine_strategic_status_wrt

public static final SubLObject determine_strategic_status_wrt(SubLObject problem,
                                                              SubLObject strategic_context)

Push PROBLEM as far as it can go wrt STRATEGIC-CONTEXT trough the progression of strategic statuses.

note_problem_examined

public static final SubLObject note_problem_examined(SubLObject problem)

possibly_note_problem_strategically_examined

public static final SubLObject possibly_note_problem_strategically_examined(SubLObject problem,
                                                                            SubLObject strategy)

note_problem_possible

public static final SubLObject note_problem_possible(SubLObject problem)

possibly_note_problem_strategically_possible

public static final SubLObject possibly_note_problem_strategically_possible(SubLObject problem,
                                                                            SubLObject strategy)

note_problem_strategically_possible

public static final SubLObject note_problem_strategically_possible(SubLObject problem,
                                                                   SubLObject strategy)

possibly_note_problem_pending

public static final SubLObject possibly_note_problem_pending(SubLObject problem,
                                                             SubLObject strategic_context)

Notes that PROBLEM is pending (wrt STRATEGIC-CONTEXT) unless it is already known to be pending (wrt STRATEGIC-CONTEXT).

note_problem_pending

public static final SubLObject note_problem_pending(SubLObject problem,
                                                    SubLObject strategic_context)

Assumes that strategy activity is propagated first, since it uses that as a criterion for considering no-goodness.

possibly_note_problem_finished

public static final SubLObject possibly_note_problem_finished(SubLObject problem,
                                                              SubLObject strategic_context)

Notes that PROBLEM is finished (wrt STRATEGIC-CONTEXT) unless it is already known to be finished (wrt STRATEGIC-CONTEXT).

note_problem_finished

public static final SubLObject note_problem_finished(SubLObject problem,
                                                     SubLObject strategic_context)

Assumes that strategy activity is propagated first, since it uses that as a criterion for considering no-goodness.

consider_ramifications_of_problem_finished

public static final SubLObject consider_ramifications_of_problem_finished(SubLObject problem,
                                                                          SubLObject strategic_context)

possibly_propagate_problem_finished

public static final SubLObject possibly_propagate_problem_finished(SubLObject problem,
                                                                   SubLObject strategic_context)

strategy_note_problem_finished

public static final SubLObject strategy_note_problem_finished(SubLObject strategic_context,
                                                              SubLObject problem)

note_argument_link_added

public static final SubLObject note_argument_link_added(SubLObject link)

note_goal_link_added

public static final SubLObject note_goal_link_added(SubLObject link)

no_good_problem_p

public static final SubLObject no_good_problem_p(SubLObject problem,
                                                 SubLObject strategic_context)

neutral_problem_p

public static final SubLObject neutral_problem_p(SubLObject problem,
                                                 SubLObject strategic_context)

good_problem_p

public static final SubLObject good_problem_p(SubLObject problem,
                                              SubLObject strategic_context)

possible_problem_p

public static final SubLObject possible_problem_p(SubLObject problem,
                                                  SubLObject strategic_context)

pending_problem_p

public static final SubLObject pending_problem_p(SubLObject problem,
                                                 SubLObject strategic_context)

finished_problem_p

public static final SubLObject finished_problem_p(SubLObject problem,
                                                  SubLObject strategic_context)

totally_finished_problem_p

public static final SubLObject totally_finished_problem_p(SubLObject problem,
                                                          SubLObject strategic_context)

propagate_problem_link

public static final SubLObject propagate_problem_link(SubLObject link)

Does all propagation necessary to handle the addition of the newly created link LINK. Adding a link can never cause a problem to become no-good, but removing a link could.

propagate_proofs

public static final SubLObject propagate_proofs(SubLObject link)

repropagate_newly_opened_link

public static final SubLObject repropagate_newly_opened_link(SubLObject link,
                                                             SubLObject mapped_supporting_problem)

problem_link_open_and_repropagate_index

public static final SubLObject problem_link_open_and_repropagate_index(SubLObject link,
                                                                       SubLObject index)

problem_link_open_and_repropagate_supporting_mapped_problem

public static final SubLObject problem_link_open_and_repropagate_supporting_mapped_problem(SubLObject link,
                                                                                           SubLObject supporting_mapped_problem)

propagate_answer_link

public static final SubLObject propagate_answer_link(SubLObject link)

Does all propagation necessary to handle the addition of the newly created answer link LINK. i.e. bubbles up proofs (if any) from the supported problems of LINK to LINK's strategy.

possibly_propagate_answer_link

public static final SubLObject possibly_propagate_answer_link(SubLObject link)

Returns:: booleanp; whether you just propagated LINK

propagate_proof_to_inference

public static final SubLObject propagate_proof_to_inference(SubLObject proof,
                                                            SubLObject inference)

consider_closing_answer_link

public static final SubLObject consider_closing_answer_link(SubLObject answer_link)

Returns:: booleanp; whether ANSWER-LINK became closed due to this call.

inference_deems_answer_link_should_be_closedP

public static final SubLObject inference_deems_answer_link_should_be_closedP(SubLObject inference,
                                                                             SubLObject answer_link)

Returns:: booleanp; whether INFERENCE deems that ANSWER-LINK ought to be closed.

proof_tree_validP

public static final SubLObject proof_tree_validP(SubLObject proof)

Returns:: boolean; t iff PROOF and all its subproofs are well-formed.

depth_L

public static final SubLObject depth_L(SubLObject depth1,
                                       SubLObject depth2)

Returns:: boolean; t iff DEPTH1 is less than DEPTH2. Any integer is deemed less than :undetermined.

propagate_min_proof_depth_via_link

public static final SubLObject propagate_min_proof_depth_via_link(SubLObject link)

Propagates proof depth down via LINK.

propagate_min_proof_depth_via_link_wrt_inference

public static final SubLObject propagate_min_proof_depth_via_link_wrt_inference(SubLObject link,
                                                                                SubLObject inference)

Propagates proof depth wrt INFERENCE down via LINK.

proof_depth_L

public static final SubLObject proof_depth_L(SubLObject depth1,
                                             SubLObject depth2)

problem_strictly_within_max_proof_depthP

public static final SubLObject problem_strictly_within_max_proof_depthP(SubLObject inference,
                                                                        SubLObject problem)

Return T iff PROBLEM is strictly within (not at) the stated max proof depth of INFERENCE.

propagate_min_transformation_depth_via_link

public static final SubLObject propagate_min_transformation_depth_via_link(SubLObject link)

Propagates transformation depth down via LINK.

propagate_min_transformation_depth_via_link_wrt_inference

public static final SubLObject propagate_min_transformation_depth_via_link_wrt_inference(SubLObject link,
                                                                                         SubLObject inference)

Propagates transformation depth wrt INFERENCE down via LINK.

transformation_depth_L

public static final SubLObject transformation_depth_L(SubLObject depth1,
                                                      SubLObject depth2)

problem_strictly_within_max_transformation_depthP

public static final SubLObject problem_strictly_within_max_transformation_depthP(SubLObject inference,
                                                                                 SubLObject problem)

Return T iff PROBLEM is strictly within (not at) the stated max transformation depth of INFERENCE.

problem_transformation_allowed_wrt_max_transformation_depthP

public static final SubLObject problem_transformation_allowed_wrt_max_transformation_depthP(SubLObject inference,
                                                                                            SubLObject problem)

Return T iff transformation on PROBLEM is allowed based on the max transformation depth of INFERENCE.

logical_tactic_transformation_allowed_wrt_max_transformation_depthP

public static final SubLObject logical_tactic_transformation_allowed_wrt_max_transformation_depthP(SubLObject inference,
                                                                                                   SubLObject logical_tactic)

Return T iff transformation motivation on LOGICAL-TACTIC is allowed based on the max transformation depth of INFERENCE.

problem_has_been_transformedP

public static final SubLObject problem_has_been_transformedP(SubLObject problem,
                                                             SubLObject inference)

propagate_strategy_activity

public static final SubLObject propagate_strategy_activity(SubLObject link)

maybe_possibly_activate_problem

public static final SubLObject maybe_possibly_activate_problem(SubLObject strategy,
                                                               SubLObject problem)

Unless PROBLEM is already active in STRATEGY, notifies STRATEGY that PROBLEM might be newly active in it. If STRATEGY agrees, propagates the activity.

link_permits_activity_propagationP

public static final SubLObject link_permits_activity_propagationP(SubLObject link,
                                                                  SubLObject supporting_mapped_problem)

propagate_inference_relevance

public static final SubLObject propagate_inference_relevance(SubLObject link)

propagate_relevance_to_supporting_problem

public static final SubLObject propagate_relevance_to_supporting_problem(SubLObject problem,
                                                                         SubLObject supporting_problem)

Propagates inferential relevance from PROBLEM to SUPPORTING-PROBLEM

possibly_note_problem_relevant

public static final SubLObject possibly_note_problem_relevant(SubLObject inference,
                                                              SubLObject problem)

link_permits_relevance_propagationP

public static final SubLObject link_permits_relevance_propagationP(SubLObject link,
                                                                   SubLObject supporting_mapped_problem)

link_permits_proof_propagationP

public static final SubLObject link_permits_proof_propagationP(SubLObject link,
                                                               SubLObject supporting_mapped_problem)

consider_that_mapped_problem_could_be_irrelevant

public static final SubLObject consider_that_mapped_problem_could_be_irrelevant(SubLObject mapped_problem,
                                                                                SubLObject dependent_link)

consider_that_problem_could_be_irrelevant_to_inference

public static final SubLObject consider_that_problem_could_be_irrelevant_to_inference(SubLObject problem,
                                                                                      SubLObject inference)

problem_irrelevant_to_inferenceP

public static final SubLObject problem_irrelevant_to_inferenceP(SubLObject problem,
                                                                SubLObject inference)

Returns:: boolean; whether PROBLEM is deemed irrelevant to INFERENCE. It is deemed irrelevant if it cannot establish a way to rederive its relevance via a dependent link to something that is relevant to INFERENCE, or INFERENCE itself.

maybe_make_problem_irrelevant_to_inference

public static final SubLObject maybe_make_problem_irrelevant_to_inference(SubLObject inference,
                                                                          SubLObject problem)

Unless PROBLEM is already irrelevant to INFERENCE, notes that PROBLEM is now irrelevant to INFERENCE. Then propagates the irrelevance.

make_problem_irrelevant_to_inference

public static final SubLObject make_problem_irrelevant_to_inference(SubLObject inference,
                                                                    SubLObject problem)

propagate_inference_irrelevance

public static final SubLObject propagate_inference_irrelevance(SubLObject inference,
                                                               SubLObject link)

problem_raw_tactical_or_strategic_status

public static final SubLObject problem_raw_tactical_or_strategic_status(SubLObject problem,
                                                                        SubLObject strategic_context)

If STRATEGIC-CONTEXT is :tactical, returns PROBLEM's status. If STRATEGIC-CONTEXT is STRATEGY, returns PROBLEM's strategic status wrt STRATEGY.

set_problem_raw_tactical_or_strategic_status

public static final SubLObject set_problem_raw_tactical_or_strategic_status(SubLObject problem,
                                                                            SubLObject strategic_context,
                                                                            SubLObject status)

If STRATEGIC-CONTEXT is :tactical, sets PROBLEM's status to STATUS. If STRATEGIC-CONTEXT is STRATEGY, sets PROBLEM's raw strategic status wrt STRATEGY to STATUS.

change_and_propagate_problem_status

public static final SubLObject change_and_propagate_problem_status(SubLObject problem,
                                                                   SubLObject new_status,
                                                                   SubLObject consider_deepP,
                                                                   SubLObject strategic_context)

consider_that_problem_could_be_good

public static final SubLObject consider_that_problem_could_be_good(SubLObject problem)

Changes PROBLEM's status to a good version of its current status if it has at least one argument link which is good. Propagates the change if there is actually a change.

problem_goodP

public static final SubLObject problem_goodP(SubLObject problem)

PROBLEM is deemed good iff it has at least one proof.

good_version_of_problem_status

public static final SubLObject good_version_of_problem_status(SubLObject status)

examined_version_of_problem_status

public static final SubLObject examined_version_of_problem_status(SubLObject status)

possible_version_of_problem_status

public static final SubLObject possible_version_of_problem_status(SubLObject status)

pending_version_of_problem_status

public static final SubLObject pending_version_of_problem_status(SubLObject status)

finished_version_of_problem_status

public static final SubLObject finished_version_of_problem_status(SubLObject status)

consider_that_problem_could_be_finished

public static final SubLObject consider_that_problem_could_be_finished(SubLObject problem,
                                                                       SubLObject consider_deepP,
                                                                       SubLObject strategic_context,
                                                                       SubLObject consider_transformation_tacticsP)

problem_could_be_finishedP

public static final SubLObject problem_could_be_finishedP(SubLObject problem,
                                                          SubLObject consider_deepP,
                                                          SubLObject strategic_context,
                                                          SubLObject consider_transformation_tacticsP)

problem_link_could_be_finishedP

public static final SubLObject problem_link_could_be_finishedP(SubLObject link,
                                                               SubLObject strategic_context,
                                                               SubLObject consider_transformation_tacticsP)

split_link_could_be_finishedP

public static final SubLObject split_link_could_be_finishedP(SubLObject split_link,
                                                             SubLObject strategic_context)

join_link_could_be_finishedP

public static final SubLObject join_link_could_be_finishedP(SubLObject j_link,
                                                            SubLObject strategic_context)

consider_that_problem_could_be_no_good

public static final SubLObject consider_that_problem_could_be_no_good(SubLObject problem,
                                                                      SubLObject consider_deepP,
                                                                      SubLObject strategic_context,
                                                                      SubLObject consider_transformation_tacticsP)

default_consider_that_problem_could_be_no_good

public static final SubLObject default_consider_that_problem_could_be_no_good(SubLObject strategic_context,
                                                                              SubLObject problem,
                                                                              SubLObject consider_deepP,
                                                                              SubLObject consider_transformation_tacticsP)

Changes PROBLEM's status to no-good if it will never have any goal descendants. Propagates the change if there is actually a change.

See Also:: problem-link-no-good?

make_problem_no_good

public static final SubLObject make_problem_no_good(SubLObject problem,
                                                    SubLObject consider_deepP,
                                                    SubLObject strategic_context)

discard_all_possible_tactics

public static final SubLObject discard_all_possible_tactics(SubLObject problem)

discard_all_impossible_possible_tactics

public static final SubLObject discard_all_impossible_possible_tactics(SubLObject problem)

discard_possible_tactics_int

public static final SubLObject discard_possible_tactics_int(SubLObject problem,
                                                            SubLObject completeness,
                                                            SubLObject preference_level,
                                                            SubLObject type,
                                                            SubLObject tactic_to_not_discard,
                                                            SubLObject productivity)

consider_that_problem_could_be_strategically_pending

public static final SubLObject consider_that_problem_could_be_strategically_pending(SubLObject problem)

consider_that_problem_could_be_strategically_pending_wrt

public static final SubLObject consider_that_problem_could_be_strategically_pending_wrt(SubLObject problem,
                                                                                        SubLObject strategy)

consider_that_supported_problems_could_be_no_good

public static final SubLObject consider_that_supported_problems_could_be_no_good(SubLObject supporting_problem,
                                                                                 SubLObject consider_deepP,
                                                                                 SubLObject strategic_context)

no_good_version_of_problem_status

public static final SubLObject no_good_version_of_problem_status(SubLObject status)

problem_no_goodP

public static final SubLObject problem_no_goodP(SubLObject problem,
                                                SubLObject consider_deepP,
                                                SubLObject strategic_context,
                                                SubLObject consider_transformation_tacticsP)

A problem is considered no-good if all of its argument links are no good, and it will never have any more. Note that this is NOT the same thing as all of its supporting problems being no good.

unsatisfiable_problemP

public static final SubLObject unsatisfiable_problemP(SubLObject problem,
                                                      SubLObject consider_deepP,
                                                      SubLObject strategic_context,
                                                      SubLObject consider_transformation_tacticsP)

problem_has_some_open_obviously_neutral_argument_linkP

public static final SubLObject problem_has_some_open_obviously_neutral_argument_linkP(SubLObject problem,
                                                                                      SubLObject consider_deepP,
                                                                                      SubLObject strategic_context,
                                                                                      SubLObject consider_transformation_tacticsP)

some_no_good_split_argument_linkP

public static final SubLObject some_no_good_split_argument_linkP(SubLObject problem,
                                                                 SubLObject consider_deepP,
                                                                 SubLObject strategic_context,
                                                                 SubLObject consider_transformation_tacticsP)

some_no_good_join_ordered_argument_linkP

public static final SubLObject some_no_good_join_ordered_argument_linkP(SubLObject problem,
                                                                        SubLObject consider_deepP,
                                                                        SubLObject strategic_context,
                                                                        SubLObject consider_transformation_tacticsP)

some_no_good_join_argument_linkP

public static final SubLObject some_no_good_join_argument_linkP(SubLObject problem,
                                                                SubLObject consider_deepP,
                                                                SubLObject strategic_context,
                                                                SubLObject consider_transformation_tacticsP)

problem_link_no_goodP

public static final SubLObject problem_link_no_goodP(SubLObject link,
                                                     SubLObject consider_deepP,
                                                     SubLObject strategic_context,
                                                     SubLObject consider_transformation_tacticsP)

A link is considered no-good if at least one of its supporting problems is no good. If transformation tactics are not being considered, a problem can sometimes be deemed no-good if it is removally and structurally no-good.

problem_no_good_ignoring_transformation_tacticsP

public static final SubLObject problem_no_good_ignoring_transformation_tacticsP(SubLObject problem,
                                                                                SubLObject strategic_context)

Returns:: boolean; t iff PROBLEM is no good if you ignore its transformation tactics (if any).

problem_link_has_some_open_obviously_neutral_supporting_mapped_problemP

public static final SubLObject problem_link_has_some_open_obviously_neutral_supporting_mapped_problemP(SubLObject link,
                                                                                                       SubLObject strategic_context)

link_permits_no_good_propagation_to_supported_problemsP

public static final SubLObject link_permits_no_good_propagation_to_supported_problemsP(SubLObject link)

propagate_proof_spec_via_answer_link

public static final SubLObject propagate_proof_spec_via_answer_link(SubLObject answer_link)

propagate_proof_spec

public static final SubLObject propagate_proof_spec(SubLObject link)

problem_has_some_proof_spec_to_propagateP

public static final SubLObject problem_has_some_proof_spec_to_propagateP(SubLObject problem)

find_or_create_problem

public static final SubLObject find_or_create_problem(SubLObject store,
                                                      SubLObject query,
                                                      SubLObject complexP)

Returns:: nil or mapped-problem-p; its problem will be a canonical problem isomorphic to the one whose identity criterion is QUERY. If one already exists, it will be returned, otherwise a new one will be created. Its variable map will be of the form: returned problem vars -> QUERY's vars. i.e. a binding list of HL variables, indicating which HL variables in the query of the returned problem (the first elements) were bound to which HL variables in QUERY (the second elements) to establish the isomorphism.

find_problem_int

public static final SubLObject find_problem_int(SubLObject store,
                                                SubLObject query,
                                                SubLObject complexP)

Parameters:: COMPLEX? - booleanp; whether to use the complex problem index as well
Returns:: 2 the canonical query extracted from QUERY
See Also:: returns an additional value:

find_or_create_problem_from_subclause_spec

public static final SubLObject find_or_create_problem_from_subclause_spec(SubLObject store,
                                                                          SubLObject contextualized_clause,
                                                                          SubLObject subclause_spec)

Return a problem in STORE whose query is the literals from CONTEXTUALIZED-CLAUSE specified by SUBCLAUSE-SPEC.

find_or_create_problem_without_subclause_spec

public static final SubLObject find_or_create_problem_without_subclause_spec(SubLObject store,
                                                                             SubLObject contextualized_clause,
                                                                             SubLObject subclause_spec)

Return a problem in STORE whose query is CONTEXTUALIZED-CLAUSE without the literals specified by SUBCLAUSE-SPEC.

find_or_create_root_problem_and_link

public static final SubLObject find_or_create_root_problem_and_link(SubLObject inference)

new_root_answer_link

public static final SubLObject new_root_answer_link(SubLObject inference,
                                                    SubLObject mapped_root_problem)

Hooks up the answer link between the root subproblem and the strategy, but intentionally doesn't propagate it yet -- this is part of A-Brain behaviour, not initialization.

find_or_create_root_problem

public static final SubLObject find_or_create_root_problem(SubLObject store,
                                                           SubLObject query)

possibly_note_eager_pruning_problem

public static final SubLObject possibly_note_eager_pruning_problem(SubLObject problem)

consider_pruning_ramifications_of_ignored_strategem

public static final SubLObject consider_pruning_ramifications_of_ignored_strategem(SubLObject strategy,
                                                                                   SubLObject strategem)

declare_inference_worker_file

public static final SubLObject declare_inference_worker_file()

init_inference_worker_file

public static final SubLObject init_inference_worker_file()

setup_inference_worker_file

public static final SubLObject setup_inference_worker_file()

declareFunctions

public void declareFunctions()

Description copied from interface: SubLFile

Declares the mapping between functions and symbols for all named functions defined in the file. Like CRTL define.

initializeVariables

public void initializeVariables()

Description copied from interface: SubLFile

Initializes all global variables and private internal variables for constants defined in the file. Like CRTL init.

runTopLevelForms

public void runTopLevelForms()

Description copied from interface: SubLFile

Runs all top-level forms in order. Like CRTL setup.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.cyc.cycjava.cycl.inference.harness Class inference_worker

me

myName

$currently_executing_tactic$

$currently_active_problem$

$asent_of_currently_executing_tactic$

$mt_of_currently_executing_tactic$

$eager_proof_validationP$

$proof_bubbling_depth$

$max_proof_bubbling_depth$

$disable_link_propagationP$

$reconsidering_set_asidesP$

$problem_store_prune_reports$

$list0

$sym1$CLET

$sym2$_CURRENTLY_EXECUTING_TACTIC_

$list3

$sym4$_CURRENTLY_ACTIVE_PROBLEM_

$list5

$list6

$sym7$_NEGATION_BY_FAILURE_

$sym8$PROBLEM_STORE_NEGATION_BY_FAILURE_

$sym9$PROBLEM_P

$str10$_a_was_not_an__unexamined_problem

$str11$_a_was__unexamined_but_somehow_go

$kw12$TACTICAL

$kw13$SKIP

$kw14$POS

$kw15$NEG

$list16

$sym17$STRATEGY_P

$kw18$NON_DISCARDED

$str19$unexpected_tactic__S

$str20$Tried_to_recursively_execute__a

$str21$Tried_to_execute_a_tactic_that_wa

$str22$unexpected_tactic__s

$list23

$sym24$_ASENT_OF_CURRENTLY_EXECUTING_TACTIC_

$sym25$_MT_OF_CURRENTLY_EXECUTING_TACTIC_

$str26$Got_a_literal_level_tactic__s_tha

$str27$Unexpected_multiple_clause_tactic

$str28$Unexpected_multiple_literal_tacti

$str29$Unexpected_structural_multiple_li

$str30$Unexpected_meta_structural_multip

$str31$unexpected_connected_conjunction_

$str32$unexpected_connected_conjunction_

$str33$unexpected_disjunctive_link__s

$str34$_s_was_not_a_logical_link_with_un

$kw35$SPLIT

$kw36$JOIN_ORDERED

$kw37$UNION

$kw38$JOIN

$str39$Unexpected_logical_tactic_module_

$str40$Join_tactics_like__S_do_not_have_

$sym41$STRUCTURAL_PROOF_P

$str42$_a_is_not_a_CONTENT_LINK_P

$sym43$CONTENT_TACTIC_P

$str44$Unexpected_content_tactic__S

$str45$Unexpected_removal_tactic__S

$kw46$REMOVAL

$kw47$RESTRICTION

$sym48$CONJUNCTIVE_REMOVAL_TACTIC_P

$sym49$SPLIT_LINK_P

$sym50$TRANSFORMATION_TACTIC_P

$kw51$TRANSFORMATION

$sym52$REWRITE_TACTIC_P

$kw53$REWRITE

$sym54$META_REMOVAL_TACTIC_P

$sym55$STRATEGIC_CONTEXT_P

$kw56$COMPLETE

$kw57$PREFERRED

$kw58$GENERALIZED_REMOVAL

$kw59$POSSIBLE

$kw60$DISPREFERRED

$kw61$GROSSLY_DISPREFERRED

$kw62$DISALLOWED

$str63$Unexpected_preference_level__s

$kw64$CONNECTED_CONJUNCTION

$kw65$STRUCTURAL

$kw66$LOGICAL

com.cyc.cycjava.cycl.inference.harness
Class inference_worker