czer_vars

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
Class czer_vars

java.lang.Object
  com.cyc.tool.subl.util.SubLTrampolineFile
      com.cyc.tool.subl.util.SubLTranslatedFile
          com.cyc.cycjava.cycl.czer_vars

All Implemented Interfaces:: CommonSymbols, SubLFile

public final class czer_vars
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`	$accumulating_semantic_violationsP$ suppresses resetting arg-type-violations
`static SubLSymbol`	$add_term_of_unit_litsP$
`static SubLSymbol`	$arg_format_binary_preds$
`static SubLSymbol`	$arg_format_ternary_preds$
`static SubLSymbol`	$arg_genl_binary_preds$
`static SubLSymbol`	$arg_genl_ternary_preds$
`static SubLSymbol`	$arg_isa_binary_preds$
`static SubLSymbol`	$arg_isa_ternary_preds$
`static SubLSymbol`	$arg_positions$ Integers denoting the most common arg positions of fixed-arity CycL relations.
`static SubLSymbol`	$arg_quoted_isa_binary_preds$
`static SubLSymbol`	$arg_quoted_isa_ternary_preds$
`static SubLSymbol`	$assertion_key$ which function to use when accessing the formula for an assertion
`static SubLSymbol`	$assume_free_vars_are_existentially_boundP$ whether the clausifier will assume that free variables are existentially bound, as opposed to the default which is universally bound.
`static SubLSymbol`	$canon_var_function$ The function that the canonicalizer uses internally to check whether something is a variable.
`static SubLSymbol`	$canon_verboseP$ controls whether the formula is printed after each step of canonicalization.
`static SubLSymbol`	$canonical_variable_type$ determines the type of variables produced by the canonicalzer [:el-var :kb-var]
`static SubLSymbol`	$canonicalize_all_sentence_argsP$ should all sentence args (of literals or denotational functions) be canonicalized into their el version?
`static SubLSymbol`	$canonicalize_disjunction_as_enumerationP$ whether to canonicalize a disjunction over a common predicate as an #$elementOf expression
`static SubLSymbol`	$canonicalize_el_template_vars_during_queriesP$ should EL variables in EL template args be canonicalized into HL variables during asks? If t, then queries like (expansion genls (implies (isa ?OBJ :ARG1) (isa ?OBJ :ARG2))) will not be interpreted as a boolean query, and will return ((?OBJ .
`static SubLSymbol`	$canonicalize_functionsP$
`static SubLSymbol`	$canonicalize_gaf_commutative_termsP$ should commutative terms of gafs be sorted?
`static SubLSymbol`	$canonicalize_literalsP$
`static SubLSymbol`	$canonicalize_tensed_literalsP$ should tensed literals be canonicalized into their time quantified version?
`static SubLSymbol`	$canonicalize_termsP$
`static SubLSymbol`	$canonicalize_variablesP$
`static SubLSymbol`	$canonicalizer_directive_predicates$ The set of predicates which specify #$CanonicalizerDirectives.
`static SubLSymbol`	$clause_el_var_names$
`static SubLSymbol`	$clothe_naked_skolemsP$ should newly-created skolems have #$termDependsOn assertions asserted about them.
`static SubLObject`	`$const16$CycLAssertion`
`static SubLObject`	`$const17$CycLIndexedTerm`
`static SubLSymbol`	$control_1$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_2$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_3$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_4$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_5$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_6$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$control_ecaP$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$controlP$ temp: used to control canonicalizer to include (= nil) or exclude (= t) experimental code
`static SubLSymbol`	$create_narts_regardless_of_whether_within_assertP$
`static SubLSymbol`	$cryP$ flag to break on error conditions
`static SubLSymbol`	$czer_memoization_state$ dynamically bound to a memoization state for the canonicalizer
`static SubLSymbol`	$czer_quiescence_iteration_limit$ If an expression fails to quiesce after 10 iterations, give up and deem it ill-formed.
`static SubLSymbol`	$distribute_meta_over_common_elP$ should meta-knowledge distribute over multiple assertions when those assertions all share a common el formula?
`static SubLSymbol`	$distributing_meta_knowledgeP$ is distributing meta-knowledge over multiple assertions permitted?
`static SubLSymbol`	$drop_all_existentialsP$ should the canonicalizer, when canonicalizing existentials, simply drop them (like it does by default during asks)? This setting, if true, overrides the combination of within-ask and skolemize-during-asks?, but does not override the case of turn-existentials-into-skolems? being false, which will cause no existential handling at all to be done.
`static SubLSymbol`	$el_supports_contractionsP$ is support for contractions (inverse #$expansions) enabled?
`static SubLSymbol`	$el_supports_dot_syntaxP$ are sequence variables permitted?
`static SubLSymbol`	$el_supports_variable_arity_skolemsP$
`static SubLSymbol`	$el_symbol_suffix_table$ dynamic table of uniquifying el var suffixes
`static SubLSymbol`	$el_trace_level$ controls tracing level for canonicalizer [0..5]
`static SubLSymbol`	$el_var_blist$ stores the variable rename mappings formed while standardizing variables during uncanonicalization
`static SubLSymbol`	$empty_skolems$ skolems having no defining assertions encountered while reinitializing skolem-axiom-table
`static SubLSymbol`	$encapsulate_intensional_formulaP$ translate intensional (e.g., negated universally quantified) formulas into encapsulated negative literals?
`static SubLSymbol`	$encapsulate_var_formulaP$ translate variables appearing as logical operators into encapsulated literals?
`static SubLSymbol`	$expand_el_relationsP$ should #$ELRelations be automatically expanded by the precanonicalizer?
`static SubLSymbol`	$express_as_arg_genlP$
`static SubLSymbol`	$express_as_arg_isaP$
`static SubLSymbol`	$express_as_asymmetricP$
`static SubLSymbol`	$express_as_disjoint_withP$
`static SubLSymbol`	$express_as_genl_inverseP$
`static SubLSymbol`	$express_as_genl_predicatesP$
`static SubLSymbol`	$express_as_genlsP$
`static SubLSymbol`	$express_as_inter_arg_isaP$
`static SubLSymbol`	$express_as_irreflexiveP$
`static SubLSymbol`	$express_as_negation_inverseP$
`static SubLSymbol`	$express_as_negation_predicatesP$
`static SubLSymbol`	$express_as_reflexiveP$
`static SubLSymbol`	$express_as_relation_typeP$
`static SubLSymbol`	$express_as_required_arg_predP$
`static SubLSymbol`	$express_as_rule_macroP$
`static SubLSymbol`	$express_as_symmetricP$
`static SubLSymbol`	$express_as_transitiveP$
`static SubLSymbol`	$find_uncanonical_decontextualized_assertionsP$ If a decontextualized assertion is in the wrong mt, should the canonicalizer, if asked to look up that assertion, find it? If T, it will find it.
`static SubLSymbol`	$forbid_quantified_sequence_variablesP$ Whether to enforce criterion Q2 in the Sequence Variable Specification, namely: Q2: Within asserts, sequence variables can only be universally quantified; using existentially quantified variables as sequence variables is not permitted.
`static SubLSymbol`	$form_of_clausal_form$ canonicalizer state variable [:cnf :dnf]
`static SubLSymbol`	$gathering_quantified_fn_termsP$ control var used to collect non-ground reifiable fn terms
`static SubLSymbol`	$hl_pred_order$ preferred order of preds wrt canonicalization
`static SubLSymbol`	$implication_operators$
`static SubLSymbol`	$implicitify_universalsP$ whether to eliminate universals which could be removed and still maintain the logical equivalence of the sentence if they are viewed as implicitly encapsulating it.
`static SubLSymbol`	$infer_skolem_result_isa_via_arg_constraintsP$ in the absence of explicit #$isa pos-lits, use applicable arg-isa constraints to infer the #$resultIsa of a skolem?
`static SubLSymbol`	$inside_quote$ Variable to keep track if we are inside a quote form
`static SubLInteger`	`$int25$2048`
`static SubLSymbol`	$interpolate_singleton_arg_isaP$ should skolem arg-isa constraints be interpolated into a singleton set?
`static SubLSymbol`	`$kw19$ASSERT_ONLY`
`static SubLSymbol`	`$kw20$DEFAULT`
`static SubLSymbol`	`$kw21$KB_VAR`
`static SubLSymbol`	`$kw30$ASSERT`
`static SubLSymbol`	`$kw31$QUERY`
`static SubLSymbol`	$leave_skolem_constants_aloneP$ should the canonicalizer, when canonicalizing existentials that are not in the scope of any other variable, simply drop them (like it does by default during asks)? This setting, if true, overrides the combination of within-ask and skolemize-during-asks?, but does not override the case of turn-existentials-into-skolems? being false, which will cause no existential handling at all to be done.
`static SubLList`	`$list0`
`static SubLList`	`$list1`
`static SubLList`	`$list10`
`static SubLList`	`$list11`
`static SubLList`	`$list12`
`static SubLList`	`$list13`
`static SubLList`	`$list14`
`static SubLList`	`$list15`
`static SubLList`	`$list22`
`static SubLList`	`$list23`
`static SubLList`	`$list26`
`static SubLList`	`$list27`
`static SubLList`	`$list28`
`static SubLList`	`$list29`
`static SubLList`	`$list5`
`static SubLList`	`$list6`
`static SubLList`	`$list7`
`static SubLList`	`$list8`
`static SubLList`	`$list9`
`static SubLSymbol`	$logical_operators$
`static SubLSymbol`	$mal_skolems$ skolems diagnosed as having problems while reinitializing skolem-axiom-table
`static SubLSymbol`	$meta_arg_type$ arg-type for meta predicates
`static SubLSymbol`	$minimal_skolem_arityP$ should the canonicalizer include only free vars referenced in existentially quantified formulas in argument lists of the resulting skolem functions?
`static SubLSymbol`	$must_enforce_semanticsP$
`static SubLSymbol`	$nart_key$ which function to use when accessing the formula for a nart
`static SubLSymbol`	$new_canonicalizerP$ Whether to use the code for the new canonicalizer
`static SubLSymbol`	$noting_ill_formed_meta_argsP$ whether el-meta should set the value of @xref recan-ill-formed-meta-args?
`static SubLSymbol`	$possibly_meta_arg_type$ arg-type for meta predicates
`static SubLSymbol`	$preds_of_computed_skolem_gafs$ predicates for gafs that reference skolem functions that may be computed and asserted by the canonicalizer and may be manually edited
`static SubLSymbol`	$preds_of_editable_skolem_gafs$ predicates for gafs that reference skolem functions that may be computed and asserted by the canonicalizer, or the interface time-stamper, or may be manually edited
`static SubLSymbol`	$recan_ill_formed_meta_argsP$ bound by el-meta when called from the recanonicalizer, so that the recanonicalizer can correctly analyze problems with finding meta assertions (which may be due to uncanonicality).
`static SubLSymbol`	$recanonicalizing_candidate_assertion_stack$ used for recursion detection
`static SubLSymbol`	$recanonicalizing_candidate_natP$ Dynamic variable set while recanonicalizing a nat for robust nart lookup.
`static SubLSymbol`	$recanonicalizingP$ is an existing assertion being recanonicalized?
`static SubLSymbol`	$reify_skolemsP$
`static SubLSymbol`	$required_arg_preds$
`static SubLSymbol`	$rf_key$ which function to use when accessing the formula for a reified formula (the genl of nart and assertion)
`static SubLSymbol`	$robust_assertion_lookup$ Controls whether, upon failing to find an assertion, a more thorough (and more time-consuming) lookup is performed.
`static SubLSymbol`	$robust_nart_lookup$ Controls whether, upon failing to find a nart, a more thorough (and more time-consuming) lookup is performed.
`static SubLSymbol`	$semantic_violations$ descriptions of how a relational expression is not semantically valid
`static SubLSymbol`	$sequence_variable_split_limit$ The maximum number of term variables that a sequence variable can be split into if we're using the arity information to simplify.
`static SubLSymbol`	$simplify_equal_symbols_literalP$ If T, the simplifier will simplify #$equalSymbols literals with one variable argument and one bound argument by substituting the binding throughout the conjunction.
`static SubLSymbol`	$simplify_implicationP$
`static SubLSymbol`	$simplify_literalP$
`static SubLSymbol`	$simplify_non_wff_literalP$ If t, non-wff literals will be reduced to #$False.
`static SubLSymbol`	$simplify_redundanciesP$ If t, simplify-cycl-sentence will look for redundant literals and remove them.
`static SubLSymbol`	$simplify_sentenceP$
`static SubLSymbol`	$simplify_sequence_vars_using_kb_arityP$ If t, simplify-sequence-vars will use arity information from the KB to eliminate sequence variables or convert them to term variables when possible.
`static SubLSymbol`	$simplify_transitive_redundanciesP$ If t, simplify-transitive-redundancies will look for transitive redundancies and remove them.
`static SubLSymbol`	$simplify_true_sentence_awayP$ If T, the simplifier will be more zealous in simplifying #$trueSentence literals away.
`static SubLSymbol`	$simplify_using_semanticsP$ If nil, simplify-cycl-sentence will only perform syntactic simplifications.
`static SubLSymbol`	$skolem_axiom_table$ table of definitions of known skolems
`static SubLSymbol`	$skolem_function_functions$ cyc constants that denote functions whose ranges are skolem functions
`static SubLSymbol`	$skolemize_during_asksP$ should the canonicalizer translate existentially quantified vars into skolem functions during asks?
`static SubLSymbol`	$standardize_variables_memory$ stores the variable rename mappings formed while standardizing variables during canonicalization
`static SubLString`	`$str32$Canonicalizer_tense_mode_not_set_`
`static SubLSymbol`	$subordinate_fi_opsP$
`static SubLSymbol`	`$sym18$EL_VAR_`
`static SubLSymbol`	`$sym2$ASSERTION_FORMULA`
`static SubLSymbol`	`$sym24$_SKOLEM_AXIOM_TABLE_`
`static SubLSymbol`	`$sym3$NART_HL_FORMULA`
`static SubLSymbol`	`$sym4$RF_FORMULA`
`static SubLSymbol`	$tense_czer_mode$
`static SubLSymbol`	$try_to_simplify_non_wff_into_wffP$ If t, non-wffs will be simplified to see if they become wff.
`static SubLSymbol`	$trying_to_simplify_non_wff_into_wffP$ transient state variable, t iff we're in the middle of trying to simplify a non-wff into a wff
`static SubLSymbol`	$turn_existentials_into_skolemsP$ If you set this to NIL, the canonicalizer will be severely crippled.
`static SubLSymbol`	$uncanonicalize_tensed_literalsP$ Whether the uncanonicalizer should rephrase sentences in terms of #$was, #$willBe, etc.
`static SubLSymbol`	$unremove_universalsP$ Whether the uncanonicalizer should insert #$forAlls around unquantified variables.
`static SubLSymbol`	$ununiquify_el_varsP$ Whether the uncanonicalizer should remove uniquifying numerical suffixes on EL variables.
`static SubLSymbol`	$use_czer_fort_types_globallyP$ whether to always use czer-fort types.
`static SubLSymbol`	$use_czer_fort_typesP$ whether to use czer-fort-types at all.
`static SubLSymbol`	$use_skolem_constantsP$ should the canonicalizer create and reference skolem constants instead of zero-arity skolem functions?
`static SubLSymbol`	$variables_that_cannot_be_sequence_variables$ a dynamic stack of variables that are currently not permitted to be used as sequence variables (e.g.
`static SubLSymbol`	$varP$ default predicate to identify variables
`static SubLSymbol`	$within_canonicalizerP$ transient state variable; is t during the execution of canonicalizing functions
`static SubLSymbol`	$within_negationP$ is canonicalization occuring within scope of a negation?
`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`	`declare_czer_vars_file()`
`void`	`declareFunctions()` Declares the mapping between functions and symbols for all named functions defined in the file.
`static SubLObject`	`init_czer_vars_file()`
`void`	`initializeVariables()` Initializes all global variables and private internal variables for constants defined in the file.
`void`	`runTopLevelForms()` Runs all top-level forms in order.
`static SubLObject`	`setup_czer_vars_file()`
`static SubLObject`	`valid_tense_czer_mode_p(SubLObject mode)`

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

$required_arg_preds$

public static SubLSymbol $required_arg_preds$

$arg_positions$

public static SubLSymbol $arg_positions$

Integers denoting the most common arg positions of fixed-arity CycL relations.

$accumulating_semantic_violationsP$

public static SubLSymbol $accumulating_semantic_violationsP$

suppresses resetting *arg-type-violations*

$semantic_violations$

public static SubLSymbol $semantic_violations$

descriptions of how a relational expression is not semantically valid

$assertion_key$

public static SubLSymbol $assertion_key$

which function to use when accessing the formula for an assertion

$nart_key$

public static SubLSymbol $nart_key$

which function to use when accessing the formula for a nart

$rf_key$

public static SubLSymbol $rf_key$

which function to use when accessing the formula for a reified formula (the genl of nart and assertion)

$implication_operators$

public static SubLSymbol $implication_operators$

$logical_operators$

public static SubLSymbol $logical_operators$

$skolem_function_functions$

public static SubLSymbol $skolem_function_functions$

cyc constants that denote functions whose ranges are skolem functions

$arg_isa_binary_preds$

public static SubLSymbol $arg_isa_binary_preds$

$arg_isa_ternary_preds$

public static SubLSymbol $arg_isa_ternary_preds$

$arg_quoted_isa_binary_preds$

public static SubLSymbol $arg_quoted_isa_binary_preds$

$arg_quoted_isa_ternary_preds$

public static SubLSymbol $arg_quoted_isa_ternary_preds$

$arg_genl_binary_preds$

public static SubLSymbol $arg_genl_binary_preds$

$arg_genl_ternary_preds$

public static SubLSymbol $arg_genl_ternary_preds$

$arg_format_binary_preds$

public static SubLSymbol $arg_format_binary_preds$

$arg_format_ternary_preds$

public static SubLSymbol $arg_format_ternary_preds$

$meta_arg_type$

public static SubLSymbol $meta_arg_type$

arg-type for meta predicates

$possibly_meta_arg_type$

public static SubLSymbol $possibly_meta_arg_type$

arg-type for meta predicates

$variables_that_cannot_be_sequence_variables$

public static SubLSymbol $variables_that_cannot_be_sequence_variables$

a dynamic stack of variables that are currently not permitted to be used as sequence variables (e.g. because they're scoped)

$el_supports_dot_syntaxP$

public static SubLSymbol $el_supports_dot_syntaxP$

are sequence variables permitted?

$el_supports_variable_arity_skolemsP$

public static SubLSymbol $el_supports_variable_arity_skolemsP$

$el_supports_contractionsP$

public static SubLSymbol $el_supports_contractionsP$

is support for contractions (inverse #$expansions) enabled?

$inside_quote$

public static SubLSymbol $inside_quote$

Variable to keep track if we are inside a quote form

$new_canonicalizerP$

public static SubLSymbol $new_canonicalizerP$

Whether to use the code for the new canonicalizer

$within_canonicalizerP$

public static SubLSymbol $within_canonicalizerP$

transient state variable; is t during the execution of canonicalizing functions

$form_of_clausal_form$

public static SubLSymbol $form_of_clausal_form$

canonicalizer state variable [:cnf :dnf]

$must_enforce_semanticsP$

public static SubLSymbol $must_enforce_semanticsP$

$el_trace_level$

public static SubLSymbol $el_trace_level$

controls tracing level for canonicalizer [0..5]

$canon_verboseP$

public static SubLSymbol $canon_verboseP$

controls whether the formula is printed after each step of canonicalization. only set to t for debugging purposes.

$varP$

public static SubLSymbol $varP$

default predicate to identify variables

$subordinate_fi_opsP$

public static SubLSymbol $subordinate_fi_opsP$

$cryP$

public static SubLSymbol $cryP$

flag to break on error conditions

$minimal_skolem_arityP$

public static SubLSymbol $minimal_skolem_arityP$

should the canonicalizer include only free vars referenced in existentially quantified formulas in argument lists of the resulting skolem functions?

$skolemize_during_asksP$

public static SubLSymbol $skolemize_during_asksP$

should the canonicalizer translate existentially quantified vars into skolem functions during asks?

$drop_all_existentialsP$

public static SubLSymbol $drop_all_existentialsP$

should the canonicalizer, when canonicalizing existentials, simply drop them (like it does by default during asks)? This setting, if true, overrides the combination of *within-ask* and *skolemize-during-asks?*, but does not override the case of *turn-existentials-into-skolems?* being false, which will cause no existential handling at all to be done.

See Also:: drop-all-existentials?, existentials-out

$leave_skolem_constants_aloneP$

public static SubLSymbol $leave_skolem_constants_aloneP$

should the canonicalizer, when canonicalizing existentials that are not in the scope of any other variable, simply drop them (like it does by default during asks)? This setting, if true, overrides the combination of *within-ask* and *skolemize-during-asks?*, but does not override the case of *turn-existentials-into-skolems?* being false, which will cause no existential handling at all to be done.

See Also:: leave-skolem-constants-alone?, existentials-out

$forbid_quantified_sequence_variablesP$

public static SubLSymbol $forbid_quantified_sequence_variablesP$

Whether to enforce criterion Q2 in the Sequence Variable Specification, namely: Q2: Within asserts, sequence variables can only be universally quantified; using existentially quantified variables as sequence variables is not permitted. If T, Q2 is enforced. If NIL, Q2 is not enforced. If :assert-only, Q2 is enforced iff (within-assert?).

$use_skolem_constantsP$

public static SubLSymbol $use_skolem_constantsP$

should the canonicalizer create and reference skolem constants instead of zero-arity skolem functions?

$canonicalize_gaf_commutative_termsP$

public static SubLSymbol $canonicalize_gaf_commutative_termsP$

should commutative terms of gafs be sorted?

$canon_var_function$

public static SubLSymbol $canon_var_function$

The function that the canonicalizer uses internally to check whether something is a variable. :default means that it will use the default function @xref cyc-var? (this is slightly more efficient than just making the default be #'cyc-var?)

See Also:: canon-var?

$canonical_variable_type$

public static SubLSymbol $canonical_variable_type$

determines the type of variables produced by the canonicalzer [:el-var :kb-var]

$standardize_variables_memory$

public static SubLSymbol $standardize_variables_memory$

stores the variable rename mappings formed while standardizing variables during canonicalization

$distributing_meta_knowledgeP$

public static SubLSymbol $distributing_meta_knowledgeP$

is distributing meta-knowledge over multiple assertions permitted?

$distribute_meta_over_common_elP$

public static SubLSymbol $distribute_meta_over_common_elP$

should meta-knowledge distribute over multiple assertions when those assertions all share a common el formula?

$find_uncanonical_decontextualized_assertionsP$

public static SubLSymbol $find_uncanonical_decontextualized_assertionsP$

If a decontextualized assertion is in the wrong mt, should the canonicalizer, if asked to look up that assertion, find it? If T, it will find it. If NIL, it will treat it like any other uncanonical assertion and fail to find it.

$canonicalize_el_template_vars_during_queriesP$

public static SubLSymbol $canonicalize_el_template_vars_during_queriesP$

should EL variables in EL template args be canonicalized into HL variables during asks? If t, then queries like (expansion genls (implies (isa ?OBJ :ARG1) (isa ?OBJ :ARG2))) will not be interpreted as a boolean query, and will return ((?OBJ . ?OBJ)) instead of ((T . T)). If it is set to nil, then queries like (expansion genls ?WHAT) will be interpreted as a boolean query, and will return NIL instead of the expansion of genls.

$robust_assertion_lookup$

public static SubLSymbol $robust_assertion_lookup$

Controls whether, upon failing to find an assertion, a more thorough (and more time-consuming) lookup is performed. You can set this to T or NIL if you want to control its behavior.

$robust_nart_lookup$

public static SubLSymbol $robust_nart_lookup$

Controls whether, upon failing to find a nart, a more thorough (and more time-consuming) lookup is performed. You can set this to T or NIL if you want to control its behavior.

$recanonicalizing_candidate_natP$

public static SubLSymbol $recanonicalizing_candidate_natP$

Dynamic variable set while recanonicalizing a nat for robust nart lookup.

$el_var_blist$

public static SubLSymbol $el_var_blist$

stores the variable rename mappings formed while standardizing variables during uncanonicalization

$gathering_quantified_fn_termsP$

public static SubLSymbol $gathering_quantified_fn_termsP$

control var used to collect non-ground reifiable fn terms

$expand_el_relationsP$

public static SubLSymbol $expand_el_relationsP$

should #$ELRelations be automatically expanded by the precanonicalizer?

$canonicalize_all_sentence_argsP$

public static SubLSymbol $canonicalize_all_sentence_argsP$

should all sentence args (of literals or denotational functions) be canonicalized into their el version?

$canonicalize_tensed_literalsP$

public static SubLSymbol $canonicalize_tensed_literalsP$

should tensed literals be canonicalized into their time quantified version?

$add_term_of_unit_litsP$

public static SubLSymbol $add_term_of_unit_litsP$

$turn_existentials_into_skolemsP$

public static SubLSymbol $turn_existentials_into_skolemsP$

If you set this to NIL, the canonicalizer will be severely crippled. Beware!

$reify_skolemsP$

public static SubLSymbol $reify_skolemsP$

$create_narts_regardless_of_whether_within_assertP$

public static SubLSymbol $create_narts_regardless_of_whether_within_assertP$

$canonicalize_functionsP$

public static SubLSymbol $canonicalize_functionsP$

$canonicalize_termsP$

public static SubLSymbol $canonicalize_termsP$

$canonicalize_literalsP$

public static SubLSymbol $canonicalize_literalsP$

$canonicalize_disjunction_as_enumerationP$

public static SubLSymbol $canonicalize_disjunction_as_enumerationP$

whether to canonicalize a disjunction over a common predicate as an #$elementOf expression

$canonicalize_variablesP$

public static SubLSymbol $canonicalize_variablesP$

$implicitify_universalsP$

public static SubLSymbol $implicitify_universalsP$

whether to eliminate universals which could be removed and still maintain the logical equivalence of the sentence if they are viewed as implicitly encapsulating it.

$assume_free_vars_are_existentially_boundP$

public static SubLSymbol $assume_free_vars_are_existentially_boundP$

whether the clausifier will assume that free variables are existentially bound, as opposed to the default which is universally bound. This ought to be the mode in which the clausifier is run for queries.

$encapsulate_var_formulaP$

public static SubLSymbol $encapsulate_var_formulaP$

translate variables appearing as logical operators into encapsulated literals?

$encapsulate_intensional_formulaP$

public static SubLSymbol $encapsulate_intensional_formulaP$

translate intensional (e.g., negated universally quantified) formulas into encapsulated negative literals?

$czer_quiescence_iteration_limit$

public static SubLSymbol $czer_quiescence_iteration_limit$

If an expression fails to quiesce after 10 iterations, give up and deem it ill-formed.

$clause_el_var_names$

public static SubLSymbol $clause_el_var_names$

$el_symbol_suffix_table$

public static SubLSymbol $el_symbol_suffix_table$

dynamic table of uniquifying el var suffixes

$within_negationP$

public static SubLSymbol $within_negationP$

is canonicalization occuring within scope of a negation?

$hl_pred_order$

public static SubLSymbol $hl_pred_order$

preferred order of preds wrt canonicalization