:- asserta(baseKB:ignore_file_mpreds('/home/prologmud_server/lib/swipl/pack/prologmud_samples/prolog/prologmud_sample_games/tiny_kb_cache')). :-multifile tiny_kb/3. :-dynamic tiny_kb/3. :-style_check(-singleton). tiny_kb(canonicalizerDirectiveForArg(tSetOfFormulaArgSetFn,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(vFormulaArityFn,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(expansion,2,vAllowGenericArgVariables),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(expansion,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulationPrecondition,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorEquals,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorEquals,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorEquiv,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorEquiv,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorRule,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(reformulatorRule,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(canonicalizerDirectiveForArg(trueRule,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(implies(instanceElementType(SET_TYPE,_COL),defnSufficient(SET_TYPE,uSubLQuoteFn('CYC-SET-OF-TYPE-SUFFICIENT'))),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(afterRemoving(unitMultiplicationFactor,uSubLQuoteFn('CLEAR-UNIT-MULTIPLICATION-FACTOR-CACHES')),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(afterRemoving(knownAntecedentRule,uSubLQuoteFn('CYC-REMOVE-KNOWN-ANTECEDENT-RULE')),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(afterAdding(unitMultiplicationFactor,uSubLQuoteFn('CLEAR-UNIT-MULTIPLICATION-FACTOR-CACHES')),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(afterAdding(knownAntecedentRule,uSubLQuoteFn('CYC-ADD-KNOWN-ANTECEDENT-RULE')),iUniversalVocabularyImplementationMt,vStrMon). tiny_kb(argQuotedIsa(expansion,2,ftCycLExpression),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argQuotedIsa(collectionExpansion,2,ftCycLExpression),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(expansion,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(collectionExpansion,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(canonicalizerDirectiveForArg(collectionExpansion,2,vAllowGenericArgVariables),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(canonicalizerDirectiveForArg(collectionExpansion,2,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(canonicalizerDirectiveForArg(formulaArity,1,vLeaveSomeTermsAtEL),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argQuotedIsa(expansion,2,ftCycLExpression),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argQuotedIsa(collectionExpansion,2,ftCycLExpression),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(expansion,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argIsa(collectionExpansion,2,tThing),iUniversalVocabularyImplementationMt,vStrDef). tiny_kb(argQuotedIsa(xQuasiQuoteFn,1,ftExpression),iLogicalTruthImplementationMt,vStrMon). tiny_kb(disjointWith(ftNonNegativeInteger,ftSymbol),iLogicalTruthImplementationMt,vStrMon). tiny_kb(disjointWith(rtReifiableFunction,rtUnreifiableFunction),iLogicalTruthImplementationMt,vStrMon). tiny_kb(disjointWith(rtFixedAritySkolemFunction,rtVariableAritySkolemFunction),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(termOfUnit,uSubLQuoteFn('REMOVE-TERM-OF-UNIT')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(resultIsa,uSubLQuoteFn('REMOVE-SUF-FUNCTION')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(quotedIsa,uSubLQuoteFn('QUOTED-INSTANCEOF-AFTER-REMOVING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(quotedDefnSufficient,uSubLQuoteFn('REMOVE-SUF-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(quotedDefnNecessary,uSubLQuoteFn('REMOVE-NEC-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(quotedDefnIff,uSubLQuoteFn('REMOVE-IFF-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(isa,uSubLQuoteFn('INSTANCEOF-AFTER-REMOVING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(isa,uSubLQuoteFn('CLEAR-ISA-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(genls,uSubLQuoteFn('PGIA-AFTER-REMOVING-GENLS')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(genls,uSubLQuoteFn('GENLS-AFTER-REMOVING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(genls,uSubLQuoteFn('CLEAR-GENLS-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(genlMt,uSubLQuoteFn('REMOVE-BASE-MT')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(genlMt,uSubLQuoteFn('CLEAR-MT-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(equals,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(disjointWith,uSubLQuoteFn('MDW-AFTER-REMOVING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(defnNecessary,uSubLQuoteFn('REMOVE-NEC-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(defnIff,uSubLQuoteFn('REMOVE-IFF-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(arityMin,uSubLQuoteFn('REMOVE-ARITY-MIN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(arityMax,uSubLQuoteFn('REMOVE-ARITY-MAX')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(arity,uSubLQuoteFn('REMOVE-ARITY')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(afterRemoving,uSubLQuoteFn('DECACHE-AFTER-REMOVINGS')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterRemoving(afterAdding,uSubLQuoteFn('DECACHE-AFTER-ADDINGS')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(termOfUnit,uSubLQuoteFn('ADD-TERM-OF-UNIT')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(resultIsa,uSubLQuoteFn('ADD-SUF-FUNCTION')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(quotedIsa,uSubLQuoteFn('QUOTED-INSTANCEOF-AFTER-ADDING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(quotedDefnSufficient,uSubLQuoteFn('ADD-SUF-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(quotedDefnNecessary,uSubLQuoteFn('ADD-NEC-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(quotedDefnIff,uSubLQuoteFn('ADD-IFF-QUOTED-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(isa,uSubLQuoteFn('PGIA-AFTER-ADDING-ISA')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(isa,uSubLQuoteFn('INSTANCEOF-AFTER-ADDING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(isa,uSubLQuoteFn('CLEAR-ISA-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(genls,uSubLQuoteFn('GENLS-AFTER-ADDING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(genls,uSubLQuoteFn('CLEAR-GENLS-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(genlMt,uSubLQuoteFn('CLEAR-MT-DEPENDENT-CACHES')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(genlMt,uSubLQuoteFn('ADD-BASE-MT')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(equals,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(disjointWith,uSubLQuoteFn('MDW-AFTER-ADDING')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(defnNecessary,uSubLQuoteFn('ADD-NEC-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(defnIff,uSubLQuoteFn('ADD-IFF-DEFN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(arityMin,uSubLQuoteFn('ADD-ARITY-MIN')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(arityMax,uSubLQuoteFn('ADD-ARITY-MAX')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(arity,uSubLQuoteFn('ADD-ARITY')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(afterRemoving,uSubLQuoteFn('DECACHE-AFTER-REMOVINGS')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(afterAdding(afterAdding,uSubLQuoteFn('DECACHE-AFTER-ADDINGS')),iLogicalTruthImplementationMt,vStrMon). tiny_kb(argQuotedIsa(termOfUnit,1,ftReifiableNonAtomicTerm),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(arity,2,ftNonNegativeInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(argIsa,2,ftPositiveInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(argAndRestIsa,2,ftPositiveInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(xQuoteFn,1,ftExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(xEscapeQuoteFn,1,ftExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argIsa(defnIff,1,tCol),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argIsa(afterRemoving,1,tPred),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argIsa(afterAdding,1,tPred),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tPred(termOfUnit),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tPred(defnIff),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tPred(afterRemoving),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tPred(afterAdding),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(rtVariableAritySkolemFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(rtUnreifiableFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(ftSymbol),iLogicalTruthImplementationMt,vStrDef). tiny_kb(ttExpressionType(ftPositiveInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(ftPositiveInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(ftNonNegativeInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(rtSkolemFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(rtReifiableFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(rtUnreifiableFunction(xQuoteFn),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tMicrotheory(iLogicalTruthImplementationMt),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(rtFixedAritySkolemFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(rtUnreifiableFunction(xEscapeQuoteFn),iLogicalTruthImplementationMt,vStrDef). tiny_kb(tCol(ftReifiableNonAtomicTerm),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtVariableAritySkolemFunction,rtVariableArityRelation),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtVariableAritySkolemFunction,rtSkolemFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtUnreifiableFunction,tFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(ftSymbol,ftCycLExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(ftPositiveInteger,ftNonNegativeInteger),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftCycLExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtSkolemFunction,rtReifiableFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtReifiableFunction,tFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtFixedAritySkolemFunction,rtSkolemFunction),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(rtFixedAritySkolemFunction,rtFixedArityRelation),iLogicalTruthImplementationMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftCycLExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(arity(termOfUnit,2),iLogicalTruthImplementationMt,vStrDef). tiny_kb(arity(defnIff,2),iLogicalTruthImplementationMt,vStrDef). tiny_kb(arity(afterRemoving,2),iLogicalTruthImplementationMt,vStrDef). tiny_kb(arity(afterAdding,2),iLogicalTruthImplementationMt,vStrDef). tiny_kb(argQuotedIsa(termOfUnit,2,ftReifiableNonAtomicTerm),iLogicalTruthImplementationMt,vStrDef). tiny_kb(defnIff(tThing,uSubLQuoteFn('TRUE')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(defnIff(ftPositiveInteger,uSubLQuoteFn('CYC-POSITIVE-INTEGER')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(defnIff(ftNonNegativeInteger,uSubLQuoteFn('CYC-NON-NEGATIVE-INTEGER')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(resultIsa(xQuoteFn,ftExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(resultIsa(xQuasiQuoteFn,ftExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(resultIsa(xEscapeQuoteFn,ftExpression),iLogicalTruthImplementationMt,vStrDef). tiny_kb(quotedDefnIff(ftSymbol,uSubLQuoteFn('SYMBOLP')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(quotedDefnIff(ftPositiveInteger,uSubLQuoteFn('CYC-POSITIVE-INTEGER')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(quotedDefnIff(ftNonNegativeInteger,uSubLQuoteFn('CYC-NON-NEGATIVE-INTEGER')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(quotedDefnIff(ftReifiableNonAtomicTerm,uSubLQuoteFn('CYCL-REIFIABLE-NON-ATOMIC-TERM?')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(quotedDefnIff(ftCycLExpression,uSubLQuoteFn('CYCL-EXPRESSION?')),iLogicalTruthImplementationMt,vStrDef). tiny_kb(implies(and(quotedIsa(SUBL_NUM,ftPositiveInteger),denotes(SUBL_NUM,NUM)),ftPositiveInteger(NUM)),iLogicalTruthImplementationMt,vStrDef). tiny_kb(implies(and(quotedIsa(SUBL_NUM,ftNonNegativeInteger),denotes(SUBL_NUM,NUM)),ftNonNegativeInteger(NUM)),iLogicalTruthImplementationMt,vStrDef). tiny_kb(transitiveViaArg(canonicalizerDirectiveForAllArgs,genlCanonicalizerDirectives,2),iCoreCycLImplementationMt,vStrMon). tiny_kb(transitiveViaArg(canonicalizerDirectiveForArg,genlCanonicalizerDirectives,3),iCoreCycLImplementationMt,vStrMon). tiny_kb(transitiveViaArg(canonicalizerDirectiveForArgAndRest,genlCanonicalizerDirectives,3),iCoreCycLImplementationMt,vStrMon). tiny_kb(genlCanonicalizerDirectives(vLeaveSomeTermsAtELAndAllowKeywordVariables,vLeaveSomeTermsAtEL),iCoreCycLImplementationMt,vStrMon). tiny_kb(genlCanonicalizerDirectives(vLeaveSomeTermsAtELAndAllowKeywordVariables,vAllowKeywordVariables),iCoreCycLImplementationMt,vStrMon). tiny_kb(genlCanonicalizerDirectives(vLeaveSomeTermsAtEL,vLeaveVariablesAtEL),iCoreCycLImplementationMt,vStrMon). tiny_kb(genlCanonicalizerDirectives(vAllowKeywordVariables,vAllowGenericArgVariables),iCoreCycLImplementationMt,vStrMon). tiny_kb(implies(canonicalizerDirectiveForArgAndRest(RELN,1,DIRECTIVE),canonicalizerDirectiveForAllArgs(RELN,DIRECTIVE)),iCoreCycLImplementationMt,vStrMon). tiny_kb(implies(canonicalizerDirectiveForAllArgs(RELN,DIRECTIVE),canonicalizerDirectiveForArgAndRest(RELN,1,DIRECTIVE)),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterRemoving(ruleAfterRemoving,uSubLQuoteFn('DECACHE-RULE-AFTER-REMOVINGS')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterRemoving(ruleAfterAdding,uSubLQuoteFn('DECACHE-RULE-AFTER-ADDINGS')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterRemoving(except,uSubLQuoteFn('CYC-EXCEPT-REMOVED')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterRemoving(evaluationResultQuotedIsa,uSubLQuoteFn('REMOVE-SUF-QUOTED-FUNCTION')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterAdding(ruleAfterRemoving,uSubLQuoteFn('DECACHE-RULE-AFTER-REMOVINGS')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterAdding(ruleAfterAdding,uSubLQuoteFn('DECACHE-RULE-AFTER-ADDINGS')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterAdding(except,uSubLQuoteFn('CYC-EXCEPT-ADDED')),iCoreCycLImplementationMt,vStrMon). tiny_kb(afterAdding(evaluationResultQuotedIsa,uSubLQuoteFn('ADD-SUF-QUOTED-FUNCTION')),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(genlCanonicalizerDirectives,"A transitive binary predicate that relates a given \nCanonicalizerDirective (q.v.) to more general ones.\n(genlCanonicalizerDirectives SPEC-DIRECTIVE GENL-DIRECTIVE) \nmeans that SPEC-DIRECTIVE is at least as specific a (set of) \ndirection(s) to the CycCanonicalizer as GENL-DIRECTIVE. \nThat is, all the commands indicated by GENL-DIRECTIVE (and\npossibly others as well) are indicated by SPEC-DIRECTIVE. \nFor example, (genlCanonicalizerDirectives\nLeaveSomeTermsAtELAndAllowKeywordVariables \nAllowKeywordVariables) holds."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(canonicalizerDirectiveForArgAndRest,"A CanonicalizerDirectivePredicate (q.v.) used (in conjunction with a CanonicalizerDirective) to control the behavior of the CycCanonicalizer. (canonicalizerDirectiveForArgAndRest RELN N DIRECTIVE) means that the CycCanonicalizer obeys DIRECTIVE when canonicalizing the Nth and subsequent (i.e. (N+1)th, (N+2)th, ...) arguments of any CycLFormula whose main (or \"0th place\") operator denotes RELN. See the instances of CanonicalizerDirective for more information on how particular directives affect canonicalization. Also see canonicalizerDirectiveForArg and canonicalizerDirectiveForAllArgs."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(canonicalizerDirectiveForArg,"A CanonicalizerDirectivePredicate (q.v.) used (in conjunction with a CanonicalizerDirective) to control the behavior of the CycCanonicalizer. (canonicalizerDirectiveForArg RELN N DIRECTIVE) means that the CycCanonicalizer obeys DIRECTIVE when canonicalizing the Nth argument of a CycLFormula whose main (or \"0th place\") operator denotes RELN. See the instances of CanonicalizerDirective for more information on how particular directives affect canonicalization. Also see canonicalizerDirectiveForArgAndRest and canonicalizerDirectiveForAllArgs."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(canonicalizerDirectiveForAllArgs,"A CanonicalizerDirectivePredicate (q.v.) used (in conjunction with a CanonicalizerDirective) to control the behavior of the CycCanonicalizer. (canonicalizerDirectiveForAllArgs RELN DIRECTIVE) means that the CycCanonicalizer obeys DIRECTIVE when canonicalizing any argument of a CycLFormula whose main (or \"0th place\") operator denotes RELN. See the instances of CanonicalizerDirective for more information on how particular directives affect canonicalization. Also see canonicalizerDirectiveForArg and canonicalizerDirectiveForArgAndRest."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vLeaveVariablesAtEL,"A CanonicalizerDirective (q.v.) that directs the canonicalizer to refrain from canonicalizing ELVariables into HLVariables.\nA consequence of this is that any CycLAssertion that contains no HL variables, regardless of its form, will be treated by the canonicalizer as if it were a GAF (see CycLClosedAtomicSentence) as opposed to a rule. Note that this will inhibit nat reification if there are variables within the scope of the reifiable function."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vLeaveSomeTermsAtELAndAllowKeywordVariables,"A CanonicalizerDirective which combines the directives LeaveSomeTermsAtEL and AllowKeywordVariables."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vLeaveSomeTermsAtELAndAllowKeywordVariables,"A CanonicalizerDirective (q.v.) that is a specialization (see genlCanonicalizerDirectives) of both LeaveSomeTermsAtEL and AllowKeywordVariables (qq.v.), and thus combines the commands of both of those directives."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vLeaveSomeTermsAtEL,"A CanonicalizerDirective (q.v.) that combines the following three commands:\n

\n(1) Do not canonicalize ELVariables into HLVariables.\n(2) Do not expand CycLFormulas whose operators are instances of ELRelation.\n(3) Do not reify CycLReifiableNonAtomicTerms.\n

\nA consequence of (1) is that any CycLAssertion that contains no HL variables, regardless of its form, will be treated by the canonicalizer as if it were a GAF (see CycLClosedAtomicSentence) as opposed to a rule."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vDontReOrderCommutativeTerms,"A CanonicalizerDirective (q.v.) that directs the CycCanonicalizer not to re-order commutative terms that appear in the CycL assertions."),iCoreCycLImplementationMt,vStrMon). tiny_kb(comment(vtCanonicalizerDirective,"A specialization of AspatialInformationStore. Instances of CanonicalizerDirective are directives (or \"commands\") that can be given to the CycCanonicalizer (via certain CanonicalizerDirectivePredicates) in order to control its behavior in certain ways during asserts and queries. Examples include AllowGenericArgVariables and LeaveSomeTermsAtEL. See e.g. the directive predicate canonicalizerDirectiveForArg for more information on how to use these directives."),iCoreCycLImplementationMt,vStrMon). tiny_kb(implies(vtDayOfWeekType(WEEKDAY),defnSufficient(WEEKDAY,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN'))),iCoreCycLImplementationMt,vStrMon). tiny_kb(implies(and(ftPositiveInteger(N),greaterThanOrEqualTo(N,ARGNUM),greaterThanOrEqualTo(ARITY,N),arity(RELN,ARITY),canonicalizerDirectiveForArgAndRest(RELN,ARGNUM,DIRECTIVE)),canonicalizerDirectiveForArg(RELN,N,DIRECTIVE)),iCoreCycLImplementationMt,vStrMon). tiny_kb(implies(and(ftPositiveInteger(N),greaterThanOrEqualTo(ARITY,N),arity(RELN,ARITY),canonicalizerDirectiveForAllArgs(RELN,DIRECTIVE)),canonicalizerDirectiveForArg(RELN,N,DIRECTIVE)),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(unknownSentence),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(termOfUnit),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(termChosen),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(sentenceEquiv),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(performSubL),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nthSmallestElement),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestIsa),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestGenls),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestGenlPreds),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestGenlMt),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestDifferentIsa),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestDifferentGenls),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestCommonSpecs),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestCommonIsa),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestCommonGenls),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(nearestCommonGenlMt),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(natFunction),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(natArgumentsEqual),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(natArgument),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(myCreator),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(myCreationTime),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(myCreationSecond),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(myCreationPurpose),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(knownSentence),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(integerBetween),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(exactlyAssertedEL_next),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(evaluate),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(equalSymbols),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(differentSymbols),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(different),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(constantName),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(constantID),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(constantGUID),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(assertedTermSentences),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(call_u_no_bc),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(assertedPredicateArg),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(admittedSentence),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(admittedArgument),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(istAsserted),iCoreCycLImplementationMt,vStrMon). tiny_kb(backchainForbidden(equalStringsCaseinsensitive),iCoreCycLImplementationMt,vStrMon). tiny_kb(notAssertible(genlCanonicalizerDirectives),iCoreCycLImplementationMt,vStrMon). tiny_kb(notAssertible(evaluate),iCoreCycLImplementationMt,vStrMon). tiny_kb(completelyEnumerableCollection(vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrMon). tiny_kb(tPred(ruleAfterRemoving),iCoreCycLImplementationMt,vStrDef). tiny_kb(tPred(ruleAfterAdding),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(cycVariableAritySkolemFuncN),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftTheTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftString),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftRealNumber),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftNonVariableSymbol),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftList),iCoreCycLImplementationMt,vStrDef). tiny_kb(ttExpressionType(ftKeyword),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftKeyword),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftInt),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftCharacter),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftAtom),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(cycSkolemFuncN),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(tRuleTemplate),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vRelaxArgTypeConstraintsForVariables),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(tReformulatorIrrelevantFORT),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(tReformulatorHighlyRelevantFORT),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(rtReformulatorDirectivePredicate),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vLeaveVariablesAtEL),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vLeaveSomeTermsAtELAndAllowKeywordVariables),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vLeaveSomeTermsAtEL),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(rtInferenceRelatedBookkeepingPredicate),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(cycFixedAritySkolemFuncN),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(iELRelationOneWay),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vDontReOrderCommutativeTerms),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(rtDefaultMonotonicPredicate),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(rtReformulationRulePredicate),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(ftIndexedTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(vtAssertionDirection),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(vtHLTruthValue),iCoreCycLImplementationMt,vStrDef). tiny_kb(tCol(mtBroadMicrotheory),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vAllowKeywordVariables),iCoreCycLImplementationMt,vStrDef). tiny_kb(vtCanonicalizerDirective(vAllowGenericArgVariables),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(cycVariableAritySkolemFuncN,rtVariableAritySkolemFunction),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(cycVariableAritySkolemFuncN,cycSkolemFuncN),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftSymbol,ftAtom),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftString,ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftString,ftAtom),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftRealNumber,ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftPositiveInteger,ftInt),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftNonVariableSymbol,ftSymbol),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftNonVariableSymbol,ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftInt),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftInt,ftRealNumber),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftCharacter,ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftAtomicTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(cycSkolemFuncN,rtSkolemFunction),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(cycFixedAritySkolemFuncN,cycSkolemFuncN),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(cycFixedAritySkolemFuncN,rtFixedAritySkolemFunction),iCoreCycLImplementationMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftIndexedTerm),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,3,vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,3,vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,2,vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,2,ftPositiveInteger),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,2,ftPositiveInteger),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,2,vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(ruleAfterRemoving,1,tPred),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(ruleAfterAdding,1,tPred),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,1,vtCanonicalizerDirective),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,1,tRelation),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,1,tRelation),iCoreCycLImplementationMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,1,tRelation),iCoreCycLImplementationMt,vStrDef). tiny_kb(genlPreds(canonicalizerDirectiveForArgAndRest,canonicalizerDirectiveForArg),iCoreCycLImplementationMt,vStrDef). tiny_kb(implies(hypotheticalTerm(TERM),quotedIsa(TERM,ftIndeterminateTerm)),iCoreCycLImplementationMt,vStrDef). tiny_kb(implies(hypotheticalTerm(TERM),highlyRelevantTerm(TERM)),iCoreCycLImplementationMt,vStrDef). tiny_kb(implies(hypotheticalTerm(TERM),ephemeralTerm(TERM)),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(resultQuotedIsa,uSubLQuoteFn('REMOVE-SUF-QUOTED-FUNCTION')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(hlPrototypicalInstance,uSubLQuoteFn('HL-PROTOTYPICAL-INSTANCE-AFTER-REMOVING')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(highlyRelevantTerm,uSubLQuoteFn('CYC-REMOVE-RELEVANT-TERM')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(canonicalizerDirectiveForArgAndRest,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(canonicalizerDirectiveForArg,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(canonicalizerDirectiveForAllArgs,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg6Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg5Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg4Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg3Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg2Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterRemoving(arg1Isa,uSubLQuoteFn('CYC-REMOVE-FROM-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(resultQuotedIsa,uSubLQuoteFn('ADD-SUF-QUOTED-FUNCTION')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(irrelevantTerm,uSubLQuoteFn('CYC-REMOVE-IRRELEVANT-TERM')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(irrelevantTerm,uSubLQuoteFn('CYC-ADD-IRRELEVANT-TERM')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(hlPrototypicalInstance,uSubLQuoteFn('HL-PROTOTYPICAL-INSTANCE-AFTER-ADDING')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(highlyRelevantTerm,uSubLQuoteFn('CYC-ADD-RELEVANT-TERM')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(canonicalizerDirectiveForArgAndRest,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(canonicalizerDirectiveForArg,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(canonicalizerDirectiveForAllArgs,uSubLQuoteFn('RECACHE-SOME-CANONICALIZER-DIRECTIVE-ASSERTIONS-SOMEWHERE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg6Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg5Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg4Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg3Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg2Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(afterAdding(arg1Isa,uSubLQuoteFn('CYC-ADD-TO-ARG-TYPE-CACHE')),iCoreCycLImplementationMt,vStrDef). tiny_kb(comment(vRelaxArgTypeConstraintsForVariables,"A CanonicalizerDirective (q.v.) that directs the CycCanonicalizer (specifically, the CycWellFormednessChecker) to relax the argument-type constraints it usually imposes on variables. For example, this canonicalizer directive would allow the sentence `(and (isa ?X Collection) (isa ?X Individual))' to be admitted, though it would otherwise be rejected as ill-formed due to the mutually disjoint argument-type constraints (see ArgTypePredicate) on the positions occupied by the two occurrences of the variable `?X'."),iCoreCycLImplementationMt,vStrDef). tiny_kb(comment(vAllowKeywordVariables,"A CanonicalizerDirective (q.v.) that is a specialization (see genlCanonicalizerDirectives) of AllowGenericArgVariables. AllowKeywordVariables directs the CycCanonicalizer to allow all \"keyword variables\" (e.g. `:NOUN' and `:ARG1') to appear in CycL assertions and to treat them as if they were CycLVariables."),iCoreCycLImplementationMt,vStrDef). tiny_kb(comment(vAllowGenericArgVariables,"A CanonicalizerDirective (q.v.) that directs the CycCanonicalizer to allow \"generic argument keyword variables\" (e.g. `:ARG1' and `:ARG2') to appear in CycL assertions and to treat them as if they were CycLVariables. For a specialization (see genlCanonicalizerDirectives) of this directive that is used to direct the canonicalizer to allow _all_ keyword variables, see AllowKeywordVariables."),iCoreCycLImplementationMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticallyNormal,2,ftAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(argQuotedIsa(myCreationTime,1,ftConstant),iUniversalVocabularyMt,vStrMon). tiny_kb(argQuotedIsa(meetsPragmaticRequirement,2,ftAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(argQuotedIsa(comment,2,ftString),iUniversalVocabularyMt,vStrMon). tiny_kb(argQuotedIsa(comment,1,ftIndexedTerm),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(pragmaticallyNormal,1,ftList),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(meetsPragmaticRequirement,1,ftList),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationInstanceExistsFn,3,tCol),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationInstanceExistsFn,2,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationInstanceExistsFn,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationExistsInstanceFn,3,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationExistsInstanceFn,2,tCol),iUniversalVocabularyMt,vStrMon). tiny_kb(argIsa(uRelationExistsInstanceFn,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(argAndRestIsa(commutativeInArgsAndRest,2,ftPositiveInteger),iUniversalVocabularyMt,vStrMon). tiny_kb(argAndRestIsa(commutativeInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrMon). tiny_kb(relationAllInstance(resultIsa,ttUnitOfMeasure,vtScalarInterval),iUniversalVocabularyMt,vStrMon). tiny_kb(relationAllInstance(resultIsa,ttUnitOfMeasure,vtScalarInterval),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtVariableArityRelation,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtUnaryPredicate,1,rtUnaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtTernaryPredicate,1,rtTernaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtQuintaryPredicate,1,rtQuintaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtQuaternaryPredicate,1,rtQuaternaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,2,rtBinaryPredicate,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genls,2,ttExpressionType,1,ttExpressionType),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,2,rtUnaryPredicate,1,rtUnaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,2,rtTernaryPredicate,1,rtTernaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,2,rtQuintaryPredicate,1,rtQuintaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,2,rtQuaternaryPredicate,1,rtQuaternaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,2,rtBinaryPredicate,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(negationPreds,1,rtVariableArityRelation,2,rtVariableArityRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgIsa(genlPreds,1,rtVariableArityRelation,2,rtVariableArityRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(interArgDifferent,2,3),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,4,5),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,3,5),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,3,4),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,2,5),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,2,4),iUniversalVocabularyMt,vStrMon). tiny_kb(interArgDifferent(commutativeInArgs,2,3),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerableForValueInArg(indexicalReferent,iTheUser,1),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerableForValueInArg(indexicalReferent,iQueryMt,1),iUniversalVocabularyMt,vStrMon). tiny_kb(relationAllInstance(collectionConventionMt,ttAtemporalNecessarilyEssentialCollectionType,iUniversalVocabularyMt),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(admittedAllArgument,genlPreds,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg1Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg1Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg1SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg2Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg2Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg2SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg3Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg3Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg3SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg4Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg4Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg4SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg5Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg5Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg5SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg6Genl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg6Isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(arg6SometimesIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(argsGenl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(argsIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(genls,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(greaterThan,quantitySubsumes,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(isa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(quotedIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(relationAll,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(relationAllExists,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(relationAllExists,genls,3),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(relationAllInstance,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(resultGenl,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArg(resultIsa,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(admittedAllArgument,genls,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(genls,genls,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(interArgResultIsa,genls,3),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(ist,genlMt,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(microtheoryDesignationArgnum,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(negationPreds,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(negationPreds,genlPreds,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(relationAll,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(relationAllInstance,genls,2),iUniversalVocabularyMt,vStrMon). tiny_kb(transitiveViaArgInverse(sentenceDesignationArgnum,genlPreds,1),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(interArgIsa,5,vSetTheFormat),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(nthSmallestElement,4,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArgInverse,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArg,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(synonymousExternalConcept,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationInstanceAll,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsInstance,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsAll,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllInstance,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllExists,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(overlappingExternalConcept,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(nthSmallestElement,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(natArgument,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(integerBetween,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(admittedArgument,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArgInverse,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArg,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(synonymousExternalConcept,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(resultIsaArgIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationInstanceAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsInstance,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllInstance,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllExists,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(preservesGenlsInArg,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(predicateConventionMt,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(overlappingExternalConcept,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(opaqueArgument,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(nthSmallestElement,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(natFunction,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(natArgument,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(integerBetween,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(fanOutArg,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(constantGUID,2,vSingleEntry),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(collectionConventionMt,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(admittedArgument,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArgInverse,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(transitiveViaArg,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(synonymousExternalConcept,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(resultIsaArgIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationInstanceAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsInstance,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationExistsAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllInstance,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAllExists,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(relationAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(preservesGenlsInArg,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(overlappingExternalConcept,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(opaqueArgument,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(nthSmallestElement,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(natFunction,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(natArgument,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(integerBetween,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(fanOutArg,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(constantGUID,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(argFormat(admittedArgument,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrMon). tiny_kb(evaluationResultQuotedIsa(uFormulaArgFn,ftExpression),iUniversalVocabularyMt,vStrMon). tiny_kb(evaluationResultQuotedIsa(xDateEncodeStringFn,ftString),iUniversalVocabularyMt,vStrMon). tiny_kb(evaluationDefn(vModuloFn,uSubLQuoteFn('CYC-MODULO')),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(vtTruthValue,ftList),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftString,vtTruthValue),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftNonVariableNonKeywordSymbol,ftKeyword),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(rtReflexiveBinaryPredicate,rtIrreflexiveBinaryPredicate),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(rtPartiallyCommutativeRelation,rtUnaryRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(tIndividual,ttSetOrCollection),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftTruthValueSentence,ftSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftSentenceAssertible,ftNonAtomicTerm),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftRuleAssertion,ftGAFAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftSentence,ftDenotationalTerm),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(ftClosedSentence,ftNonAtomicTerm),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(rtCommutativeRelation,rtUnaryRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(rtCommutativeRelation,rtPartiallyCommutativeRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(tCol,tSetMathematical),iUniversalVocabularyMt,vStrMon). tiny_kb(disjointWith(rtBinaryRelation,rtPartiallyCommutativeRelation),iUniversalVocabularyMt,vStrMon). tiny_kb(expansion(mtVisible,trueSubL(uExpandSubLFn(':ARG1','RELEVANT-MT?'('QUOTE'(':ARG1'))))),iUniversalVocabularyMt,vStrMon). tiny_kb(expansion(vPercentFn,vQuotientFn(':ARG1',100)),iUniversalVocabularyMt,vStrMon). tiny_kb(genlMt('NART'([mtMtSpaceFn|_MT_DIMS]),iUniversalVocabularyMt),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(interArgIsa(PRED,2,IND_COL,1,DEP_COL),interArgIsa(PRED,2,IND_COL,1,DEP_COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(resultIsaArg(FUNC,5),argGenl(FUNC,5,COL)),resultIsa(FUNC,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(resultIsaArg(FUNC,4),argGenl(FUNC,4,COL)),resultIsa(FUNC,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(resultIsaArg(FUNC,3),argGenl(FUNC,3,COL)),resultIsa(FUNC,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(resultIsaArg(FUNC,2),argGenl(FUNC,2,COL)),resultIsa(FUNC,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(resultIsaArg(FUNC,1),argGenl(FUNC,1,COL)),resultIsa(FUNC,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(completeExtentDecidable(PRED),backchainForbidden(PRED)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(rtSymmetricBinaryPredicate(PRED),genlInverse(PRED,PRED)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(rtAsymmetricBinaryPredicate(PRED),negationInverse(PRED,PRED)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(ttAtemporalNecessarilyEssentialCollectionType(ANECT),decontextualizedCollection(ANECT)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(ttAtemporalNecessarilyEssentialCollectionType(ANECT),collectionConventionMt(ANECT,iUniversalVocabularyMt)),iUniversalVocabularyMt,vStrMon). tiny_kb(resultIsaArg(uRelationInstanceExistsFn,3),iUniversalVocabularyMt,vStrMon). tiny_kb(resultIsaArg(uRelationExistsInstanceFn,2),iUniversalVocabularyMt,vStrMon). tiny_kb(resultIsaArg(uRelationExistsAllFn,3),iUniversalVocabularyMt,vStrMon). tiny_kb(resultIsaArg(uRelationAllExistsFn,4),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(exists,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(termDependsOn,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(termDependsOn,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(rewriteOf,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(rewriteOf,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(quotedArgument,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(opaqueArgument,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(myCreationTime,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(myCreationSecond,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(forwardNonTriggerLiteral,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(evaluate,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(equalSymbols,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(equalSymbols,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,5),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,4),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,3),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(differentSymbols,ALL),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(definingMt,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(constantID,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(comment,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(comment,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(assertedTermSentences,2),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(assertedTermSentences,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(call_u_no_bc,1),iUniversalVocabularyMt,vStrMon). tiny_kb(quotedArgument(istAsserted,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(unitMultiplicationFactor,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(sentenceTruth,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(operatorFormulas,1),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(multiplicationUnits,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(expansion,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycTacticID,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProofID,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemStoreProofCount,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemStoreProblemCount,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemStoreLinkCount,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemStoreInferenceCount,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemStoreID,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemQuerySentence,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemProvabilityStatus,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemLinkID,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycProblemID,3),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycInferenceAnswerLink,2),iUniversalVocabularyMt,vStrMon). tiny_kb(singleEntryFormatInArgs(cycInferenceAnswerLink,1),iUniversalVocabularyMt,vStrMon). tiny_kb(ruleTemplateDirection('NART'([iCollectionRuleTemplateFn,mtHypotheticalContext]),vForwardAssertionDirection),iUniversalVocabularyMt,vStrMon). tiny_kb(rewriteOf(iTheEmptySet,tSetOfTheSetFn),iUniversalVocabularyMt,vStrMon). tiny_kb(requiredArg1Pred(ttSetOrCollection,subsetOf),iUniversalVocabularyMt,vStrMon). tiny_kb(requiredArg1Pred(ftAssertion,assertionDirection),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftTheTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftString,ftString),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftPositiveInteger,ftPositiveInteger),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftPositiveInteger,ftNonNegativeInteger),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftNonNegativeInteger,ftNonNegativeInteger),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftNonNegativeInteger,ftInt),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftInt,ftInt),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftHLPrototypicalTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftExpression,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftRepresentedTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftReifiedDenotationalTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftReifiableNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftReifiableDenotationalTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftNonAtomicReifiedTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftIndexedTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftSentence,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftCycLExpression,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftDenotationalTermAssertible,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftDenotationalTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftConstant,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftClosedNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftCycLClosedExpression,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(genlsSpecdenotesgenlinstances(ftClosedDenotationalTerm,tThing),iUniversalVocabularyMt,vStrMon). tiny_kb(opaqueArgument(conceptuallyRelated,2),iUniversalVocabularyMt,vStrMon). tiny_kb(opaqueArgument(conceptuallyRelated,1),iUniversalVocabularyMt,vStrMon). tiny_kb(omitArgIsa(uSubLQuoteFn,1),iUniversalVocabularyMt,vStrMon). tiny_kb(predicateConventionMt(predicateConventionMt,iBaseKB),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(operatorFormulas,2),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(completelyEnumerableCollection,1),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(completelyDecidableCollection,1),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(argSometimesIsa,3),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(argSometimesIsa,2),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(argSometimesIsa,1),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(admittedAllArgument,3),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(admittedAllArgument,2),iUniversalVocabularyMt,vStrMon). tiny_kb(openEntryFormatInArgs(admittedAllArgument,1),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(unknownSentence,trueSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(unknownSentence,knownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(highlyRelevantPredAssertion,irrelevantPredAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(highlyRelevantMt,irrelevantMt),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(highlyRelevantAssertion,irrelevantAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(negationPreds(conceptuallyRelated,genls),iUniversalVocabularyMt,vStrMon). tiny_kb(negationInverse(means,means),iUniversalVocabularyMt,vStrMon). tiny_kb(negationInverse(greaterThan,greaterThan),iUniversalVocabularyMt,vStrMon). tiny_kb(negationInverse(followingValue,followingValue),iUniversalVocabularyMt,vStrMon). tiny_kb(negationInverse(conceptuallyRelated,isa),iUniversalVocabularyMt,vStrMon). tiny_kb(negationInverse(conceptuallyRelated,genls),iUniversalVocabularyMt,vStrMon). tiny_kb(constrainsArg(arg2Isa,2),iUniversalVocabularyMt,vStrMon). tiny_kb(constrainsArg(arg1Isa,1),iUniversalVocabularyMt,vStrMon). tiny_kb(conceptuallyRelated(knownAntecedentRule,knownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(conceptuallyRelated(knownAntecedentRule,backchainRequired),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerableForArg(termOfUnit,2),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerableForArg(termOfUnit,1),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerableForArg(conceptuallyRelated,1),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(unknownSentence,"A unary KBDependentRelation (q.v.) that takes instances of CycLSentence as arguments. (unknownSentence SENTENCE) means that SENTENCE is not currently \"known\" by the Cyc system to be true. More precisely, the inference engine cannot prove SENTENCE using only removal (see CycRemovalModule) from the current state of the knowledge base. SENTENCE might actually be known to be false (see the specialization contradictorySentence), or its truth-value might be simply unknown in the present sense. \n

\nNote that, as a KB dependent relation, unknownSentence is notAssertible (q.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(trueSubL,"(trueSubL SUBL) states that the SubL expression SUBL evaluates to a value other than NIL. This predicate allows for a procedural test for programmatic 'truth' in the implementation language to be reflected as a CycL test for logical truth in the logical language. For example, (trueSubL (ExpandSubLFn () (integerp 42))) states that the SubL expression (integerp 42) evaluates to something other than NIL. See ExpandSubLFn for a way to denote SubL within CycL. See also evaluate and EvaluateSubLFn, and performSubL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(trueRule,"(trueRule TEMPLATE FORMULA) states that FORMULA is both true and an instantiation of the rule template TEMPLATE."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(termExternalIDString,"A predicate which relates any CycLExpression to an external\nidentification string which is guaranteed to uniquely identify the\nexpression in both time and space. (termExternalIDString EXPRESSION\nID-STRING) states that the HLExternalIDString ID-STRING is the string\nrepresentation of the unique external id for the CycLExpression\nEXPRESSION. For obvious reasons, this predicate is notAssertible.\nAlso, note that this predicate is *not* a generalization of\nconstantGUID, since the latter relates a CycLConstant to an\nentirely different string. That is to say, the termExternalIDString\nof a CycLConstant is not the same string as its constantGUID."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(termChosen,"(termChosen TERM) is true for any closed Cyc TERM, and indicates that TERM has been chosen from the set of terms in the universe of discourse. This predicate is primarily used on a variable so that the moment of choice of a particular term as the binding for that variable can be identified. There should never be methods for generating bindings for non-closed termChosen literals."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(synonymousExternalConcept,"(synonymousExternalConcept THING SOURCE STRING) means that as it occurs in the external data source SOURCE, the string STRING denotes THING."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(substring,"A binary predicate that relates an instance of CharacterString to another intance of CharacterString. (substring SUBSTRING STRING) means that SUBSTRING is a substring of STRING."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(sentenceTruth,"A KBDependentRelation (q.v.) that is used to state the truth of a given CycL sentence. (sentenceTruth SENT TRUTH) means that the CycL sentence SENT has the truth value TRUTH, which is either True or False."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(sentenceImplies,"A binary predicate that represents logical entailment in CycL. (sentenceImplies ANTECEDENT CONSEQUENT) means that CONSEQUENT can be derived from ANTECEDENT using purely logical transformations. For example, this holds by double negation:\n

\n  (sentenceImplies\n    (isa Muffet Poodle)\n    (not (not (isa Muffet Poodle))) .\n
\nNote that there are cases in which (implies ANTECEDENT CONSEQUENT) is analytically true, or necessarily true in some sense of necessity weaker than logical necessity, such that (sentenceImplies ANTECEDENT CONSEQUENT) is false. For example, whereas:\n
\n  (implies (isa Muffet Poodle) (isa Muffet Dog))\n
\nis analytically true or in some sense necessarily true,\n
\n  (sentenceImplies (isa Muffet Poodle) (isa Muffet Dog))\n
\nis not true, since the material conditional is not logically valid.\n

\nsentenceImplies also differs from implies in that whereas implies is a LogicalConnective (q.v.), sentenceImplies is merely a predicate that holds between sentences. sentenceImplies is primarily intended to be used for rules that quantify over CycL sentences."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ruleTemplateDirection,"A MetaKnowledgePredicate. (ruleTemplateDirection TEMPLATE DIRECTION) states that all assertions which are instantiations of TEMPLATE should have a direction of DIRECTION."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ruleAfterRemoving,"Whenever a new rule is unasserted, ruleAfterRemovings are called on each literal of the rule. The particular ruleAfterRemovings called depend on the predicate of the literal. (ruleAfterRemoving PRED HOOK) means that HOOK will be called on each of the rule's literals whose predicate is PRED. If the rule has multiple literals containing predicate with ruleAfterRemoving the order of execution is not guaranteed. Also, ruleAfterRemovings are retriggered on the removal of the each argument to a rule."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ruleAfterAdding,"Whenever a new rule is asserted, ruleAfterAddings are called on each literal of the rule. The particular ruleAfterAddings called depend on the predicate of the literal. (ruleAfterAdding PRED HOOK) means that HOOK will be called on each of the rule's literals whose predicate is PRED. If the rule has multiple literals containing predicate with ruleAfterAdding, the order of execution is not guaranteed. Also, ruleAfterAddings are retriggered on the addition of new arguments to an existing rule."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(resultQuotedIsa,"A binary MetaRelation predicate that holds between functions and expression-types. resultQuotedIsa indicates that any value returned by a given Function-Denotational is a \"quoted instance\" of a given expression-type. More correctly, (resultQuotedIsa FUNC TYPE) means that, for any term-sequence ARGS, if the expression (FUNC . ARGS) is an admittedNAT (q.v.), then it is an instance of the SubLExpressionType TYPE. That is, the following holds:\n

\n  (quotedIsa (FUNC . ARGS) TYPE)\n
\nAnd, equivalently, so does:\n
\n  (isa (Quote (FUNC . ARGS)) TYPE)\n
\n\nTo contrast this predicate with resultIsa: (resultIsa FUNC COL) holds just in case each defined term of the form (FUNC . ARGS) denotes an instance of COL, whereas (resultQuotedIsa FUNC COL) holds just in case each admitted (i.e. syntactically and semantically well-formed) term of the form (FUNC . ARGS) is itself an instance of COL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(resultIsaArgIsa,"(resultIsaArgIsa FUNC INT) means that the NAT resulting from a use of FUNC is a member of the same collections that the term\nin arg position INT is a member of."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(relationMemberInstance,"(relationMemberInstance PRED GROUP INST) states that for every MEMBER of GROUP the following is true: (PRED MEMBER INST). This predicate enables one to make claims about the members of a group by referencing only the group itself."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(relationInstanceMember,"(relationInstanceMember PRED INST GROUP) states that for every MEMBER of GROUP the following is true: (PRED INST MEMBER). This predicate enables one to make claims about the members of a group by referencing only the group itself."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(relationInstanceExists,"A ternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate holds between a specified thing and some instance of a given collection. (relationInstanceExists PRED THING COL) means that there exists an instance INST of COL such that (PRED THING INST) holds. It is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n

\n     (thereExists ?INST\n          (and\n               (isa ?INST COL)\n               (PRED THING ?INST))) .\n
\n

\nFor example, '(relationInstanceExists geographicalSubRegions Iran OilField)' means that there exists an oilfield in Iran. Cf. relationExistsInstance, and see the shared NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(relationAllInstance,"A ternary RuleMacroPredicate that is used to state that a given binary predicate holds between all instances of a given collection and a given thing. (relationAllInstance PRED COL THING) means that every instance INST of COL bears the relation PRED to THING such that (PRED INST THING) holds. It is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n

\n     (implies\n          (isa ?INST COL)\n          (PRED ?INST THING)) .\n
\n

\nFor example, '(relationAllInstance maxSpeed GolfCart (MilesPerHour 15))' means that the maximum speed of every golf cart is 15 miles per hour. Cf. relationInstanceAll, and see NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(relationAll,"A binary RuleMacroPredicate that relates a given unary predicate to a collection of things that the predicate holds of. (relationAll PRED COL) means that, for every instance INST of COL, (PRED INST) holds. Thus (relationAll PRED COL) is equivalent to -- and so can be used in effect as shorthand for -- (the unversal closure of) the more complex form:\n

\n  (implies \n    (isa ?INST COL) \n    (PRED ?INST)) .\n
\nFor example, (relationAll call_u_no_bc CycLAssertion) means that all CycLAssertions are asserted sentences. \n

\nSee also relationOnly and the shared NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulatorRuleProperties,"(reformulatorRuleProperties PROP RULE) means that RULE has\nthe property PROP. Most reformulator directives express an assertion\nof the form 'The reformulator should do X', for some X. In contrast,\nreformulatorRuleProperties assertions are stronger, in that they\nexpress intrinsic properties of reformulator rules, and it is a\nconsequence that the reformulator should do X in order to be\ncorrect. For example, a reformulator directive could say 'For this\nreformulator rule, if in tersification mode, the reformulator should reformulate\nthe second argument into the first argument.', whereas a reformulator\nrule property could say 'This reformulator rule's first argument is\nmore terse than its second argument.' The latter implies the former."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulatorRule,"(reformulatorRule EXPR-1 EXPR-2), asserted in the\nmicrotheory MT, means that EXPR-1 may be reformulated into EXPR-2 (or\nvice versa, based on meta-properties of this rule and what mode the\nreformulator is in) in MT\nor a specMt thereof. Free variables in EXPR-1 and EXPR-2 are shared,\nand may bind with CycL expressions which match the template. Truth\nand semantics are not necessarily preserved (see TruthPreservingReformulation).\nUse the more specific predicates reformulatorEquiv and reformulatorEquals\nwhen applicable."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulatorEquiv,"A CycLReformulationRulePredicate that relates two CycL sentences. When asserted in a Microtheory MT, (reformulatorEquiv SENTENCE-1 SENTENCE-2) means that the CycLSentence SENTENCE-1 may be reformulated into the CycLSentence SENTENCE-2, or vice versa (based on meta-properties of this rule and what mode the reformulator is in), in any Microtheory SPEC-MT such that (genlMt SPEC-MT MT) holds. Free variables in SENTENCE-1 and SENTENCE-2 are shared, and may bind with CycL sentences which match the template. Note that (reformulatorEquiv SENTENCE-1 SENTENCE-2) does _not_ necessarily imply (equiv SENTENCE-1 SENTENCE-2), although this implication would hold if the reformulation is a TruthPreservingReformulation (q.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulatorEquals,"A CycLReformulationRulePredicate that relates two CycL denotational terms. When asserted in a Microtheory MT, (reformulatorEquals TERM-1 TERM-2) means that the CycLDenotationalTerm TERM-1 may be reformulated into the CycLDenotationalTerm TERM-2, or vice-versa (based on meta-properties of this rule and what mode the reformulator is in), in any Microtheory SPEC-MT such that (genlMt SPEC-MT MT) holds. Free variables in TERM-1 and TERM-2 are shared, and may bind with CycL terms which match the template. Note that (reformulatorEquals TERM-1 TERM-2) does _not_ necessarily imply (equals TERM-1 TERM-2), although this implication would hold if the reformualtion is a TruthPreservingReformulation (q.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulationPrecondition,"(reformulationPrecondition DIRECTION PRECONDITION RULE), asserted in\nthe microtheory MT, means that the CycLReformulator may only use\nRULE in MT in the DIRECTION direction (reformulating the 'from' arg\ninto the 'to' arg) if PRECONDITION holds. PRECONDITION must be a closed CycL query, which will be asked during reformulation, and either proven true or fail to be proven."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(reformulationDirectionInMode,"(reformulationDirectionInMode DIRECTION MODE RULE), when\nasserted in the microtheory MT, tells the CycLReformulator whether to use RULE\nin the forward (ReformulationForwardDirection) or backward\n(ReformulationBackwardDirection) direction when reformulating\nCycLExpressions in MT or a specMt thereof, and when operating in the mode MODE.\nIt will reformulate the 'from' arg into the 'to' arg,\nbased on DIRECTION. ReformulationNeitherDirection\nindicates the rule is not to be used at all in this mt.\nThis concept of direction has nothing to do with the forward vs. backward rule\ndistinction in inference."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ratioOfTo,"The predicate corresponding to QuotientFn. (ratioOfTo NUM-1 NUM-2 NUM-3) holds just in case the ratio of NUM-1 to NUM-2 is NUM-3; that is, just in case (QuotientFn NUM-1 NUM-2) = NUM-3. For example, (ratioOfTo 1 2 0.5) is true because 1 divided by 2 is 0.5."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(quotedDefnSufficient,"A CycInferenceDescriptorPredicate. (quotedDefnSufficient COL TEST) means that TEST is the name of a piece of code in the SubL implementation of Cyc that specifies, and tests for, a sufficient condition for a CycL term's denoting a quoted instance of (see quotedIsa) the collection COL. If TEST returns `T' (for `True') when applied to a particular term, then that term's denotatum is considered to be a quoted instance of COL. Note that TEST isn't necessarily a necessary test for quoted membership in COL; that is, not all quoted instances of COL must pass the test, unless TEST is also a defnNecessary for COL, or the term is asserted to be a quoted instance of COL using quotedIsa. See the related predicates quotedDefnNecessary and quotedDefnIff."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(quotedDefnNecessary,"A CycInferenceDescriptorPredicate. (quotedDefnNecessary COL TEST) means that TEST is the name of a piece of code in the SubL implementation of Cyc that specifies, and tests for, a necessary condition for a CycL term's denoting a quoted instance of (see quotedIsa) the collection COL. Only if TEST returns `T' (for `True') when applied to a particular term can that term's denotatum be considered a quoted instance of COL; all terms that denote quoted instances of COL must fulfill TEST's requirements, although there may be additional requirements for denoting an instance of COL as well. However, terms asserted to be quoted instances of the collection COL using quotedIsa are exempt from fulfilling TEST's requirements. See also quotedDefnSufficient and quotedDefnIff."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(quotedDefnIff,"A CycInferenceDescriptorPredicate. (quotedDefnIff COL TEST) means that TEST is the name of a piece of code in the SubL implementation of Cyc that specifies, and tests for, a necessary and sufficient condition for a CycL term's denoting a quoted instance of (see quotedIsa) the collection COL. If and only if TEST returns `T' (for `True') when applied to a particular term can that term's denotatum be considered a quoted instance of COL; all and only terms that denote quoted instances of COL must fulfill TEST's requirements. However, terms asserted to be quoted instances of the collection COL using quotedIsa are exempt from fulfilling TEST's requirements. See also quotedDefnNecessary and quotedDefnSufficient."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(querySentence,"querySentence is an HL level predicate that allows for special handling of a sentence (especially nested sentences) as a top level query during the process of canonicalization. querySentence is not-assertible. It should not be used in any assertions."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(quantitySubsumes,"A specialization of both quantityIntersects and intangibleParts, this predicate relates a given numerically measurable ScalarInterval to those scalar intervals that it subsumes or that \"fall completely inside\" it. (quantitySubsumes SUPER SUB) means that both (i) the maximum (see maxQuantValue) of SUPER is greaterThanOrEqualTo the maximum of SUB and (ii) the minimum (see minQuantValue) of SUPER is lessThanOrEqualTo the minimum of SUB.\n

\nFor example, (Meter 2 5) -- the Distance of between 2 and 5 meters inclusive -- subsumes both (Meter 3 4) and (Meter 3 5), but not (Meter 3 6)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(predicateConventionMt,"(predicateConventionMt PRED MT) means that the predicate extent of the predicate PRED, by convention, is asserted in MT."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(pragmaticRequirement,"A MetaKnowledgePredicate that is used to place a certain kind of pragmatic precondition on the use of a given asserted rule (see CycLRuleAssertion). (pragmaticRequirement SENTENCE RULE) means that SENTENCE expresses a necessary condition on RULE's being used in any proof carried out by the Cyc inference engine. The effect of asserting this is virtually the same as that of asserting (exceptWhen (unknownSentence SENTENCE) RULE): it blocks the use of RULE when SENTENCE is not currently \"known\" by the Cyc system to be true. SENTENCE should not contain disjuncts (or canonicalize into disjuncts). Upon assertion to the knowledge base, a pragmaticRequirement sentence is transformed by the canonicalizer into a rule involving pragmaticallyNormal (q.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(performSubL,"(performSubL SUBL) states that the SubL expression SUBL has been successfully evaluated for side-effect. performSubL is evaluated as late in an inference proof as possible. See also trueSubL which evaluates usually as soon as possible in an inference. For example, (performSubL (ExpandSubLFn () (print \"Done\"))) will print out the string \"Done\" as a given proof path completes. See ExpandSubLFn for a way to denote SubL within CycL. See also EvaluateSubLFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(overlappingExternalConcept,"A predicate for mapping terms from an external data source to closely related concepts represented in Cyc. (overlappingExternalConcept THING SOURCE STRING) means that in the external data source SOURCE, the meaning of STRING has significant semantic overlap with THING."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(operatorFormulas,"A non-assertible MetaLanguagePredicate and specialization of termFormulas (q.v.) that relates CycL operators to CycL formulas in which they occur as the main operator. (operatorFormulas OPERATOR FORMULA) means that OPERATOR occurs as the main operator (i.e. in the \"arg0\" position) of FORMULA. \n

\nNote that both argument-places of operatorFormulas are implicitly \"quoted\" (see quotedArgument). So if the above operatorFormulas sentence is closed (see CycLClosedAtomicSentence), the two CycL expressions it mentions, OPERATOR and FORMULA, actually appear in that sentence -- as names of themselves. Thus, the sentence \n\n

  (operatorFormulas bordersOn (bordersOn France Germany))
\n\nis true, due to the manifest fact that the term bordersOn occurs as the main operator in the sentence (bordersOn France Germany). \n

\nNote that FORMULA in the above need not be true (if it's a sentence) or even semantically well-formed."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(omitArgIsa,"(omitArgIsa RELN N) means that the relation RELN is not asserted to have a non-quoted argument constraint in its Nth argument position, due to limitations of the Cyc system. Since every relation relates things to other things, in principle every argument position for every relation should have an argIsa constraint; however, asserting some argIsa constraints will cause certain Cyc tests to fail."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nthSmallestElement,"(nthSmallestElement X N SET FUNCTION) means that X is an element of SET that has precisely N-1 other elements with a smaller value for FUNCTION. For example, (nthSmallestElement RhodeIsland-State 1 State-UnitedStates (FunctionToArg 2 areaOfRegion)). Yet there may be more nthSmallestElements. For example, (nthSmallestElement ?X 3 (TheSet 1 2 3 -3) AbsoluteValueFn) is true for both 3 and -3 - when the elements in the set are ordered according to their absolute value both 3 and -3 are 3rd smallest elements. "),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nthLargestElement,"(nthLargestElement X N SET FUNCTION) means that X is an element of SET that has precisely N-1 other elements with a larger value for FUNCTION. For example, (nthLargestElement Alaska-State 1 State-UnitedStates (FunctionToArg 2 areaOfRegion)) means that Alaska is the largest state (no elements have a larger areaOfRegion). Yet there may be more nthLargestElements. For example, (nthLargestElement ?X 1 (TheSet 1 2 3 -3) AbsoluteValueFn) is true for both 3 and -3 ; when the elements in the set are ordered according to their absolute value both 3 and -3 are largest elements. See also nthSmallestElement."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(notAssertibleMt,"(notAssertibleMt MT) states that the Microtheory MT cannot be used as the microtheory of an assertion made to the KB; i.e., MT might be a microtheory used as scaffolding or one whose assertions are known to be complete. See also notAssertibleCollection, and notAssertible."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(notAssertibleCollection,"A UnaryPredicate used for stating a certain restriction regarding the use of a given Collection in assertions to the Cyc Knowledge Base. (notAssertibleCollection COL) means that no ground atomic formula (or \"GAF\"; see CycLClosedAtomicSentence) whose initial (or \"0th\" argument-place) term is `isa', and whose 2nd argument-place term denotes COL, can be asserted to the KB. See also notAssertible, which constrains predicates in a similar fashion."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(notAssertible,"A MetaPredicate for stating a certain restriction regarding the use of a given Predicate in assertions to the Cyc Knowledge Base. (notAssertible PRED) means that no ground atomic formula (or \"GAF\"; see CycLClosedAtomicSentence) whose initial (or \"0th\" argument-place) term denotes PRED can be asserted to the KB. In many cases, PRED will be an EvaluatablePredicate whose extent is (re)computed as necessary and never cached in the KB. \n

\nSee also notAssertibleCollection, which constrains collections \nin a similar fashion."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestIsa,"A TaxonomicSlotForAnyThing, and a specialization of isa (q.v.). (nearestIsa OBJ COL) means that COL is a \"nearest\" collection of which OBJ is an instance. That is, (isa OBJ COL) holds, OBJ is not identical to COL, and there is no reified Collection NEARER-COL distinct from OBJ and COL such that both (isa OBJ NEARER-COL) and (genls NEARER-COL COL) hold. Note that nearestIsa is non-assertible (see notAssertible), since its extension at any given time depends upon (and so must be recomputed from) the current state of the isa and genls hierarchy in the Cyc Knowledge Base."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestGenls,"A TaxonomicSlotForCollections and a KBDependentRelation (qq.v.) that is a specialization of genls. \n(nearestGenls COL NEAR-COL) means that NEAR-COL is a \"nearest\" generalization of COL. More precisely:\n

\n(i) (genls COL NEAR-COL) holds,
\n(ii) COL is not identical to NEAR-COL,
\n(iii) both COL and NEAR-COL are reified, and
\n(iv) there is no reified Collection NEARER-COL distinct from COL and NEAR-COL such that both (genls COL NEARER-COL) and (genls NEARER-COL NEAR-COL) hold.\n

\nNote that nearestGenls is non-assertible (see notAssertible), since its extension at any given time depends upon (and so must be recomputed from) the current state of the genls hierarchy in the Cyc Knowledge Base."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestDifferentIsa,"(nearestDifferentIsa OBJ-1 OBJ-2 NEAR-DIFF) means that NEAR-DIFF is a \"nearest\" collection of which OBJ-1 is an instance, but OBJ-2 is not. That is, (isa OBJ-1 NEAR-DIFF) holds, but (isa OBJ-2 NEAR-DIFF) does not, and there is no reified Collection OTHER-COL distinct from NEAR-DIFF such that (isa OBJ-1 OTHER-COL) holds, (isa OBJ-2 OTHER-COL) does not hold, and (genls OTHER-COL NEAR-DIFF) holds. Note that this predicate is notAssertible, since it must always be recomputed from the current state of the isa and genls hierarchy. For comparison, see nearestDifferentGenls."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestDifferentGenls,"(nearestDifferentGenls COL-1 COL-2 NEAR-DIFF) relates collections COL-1 and COL-2 to the nearest unsubsumed collections NEAR-DIFF of which COL-1 is a subset but COL-2 is not. This predicate is notAssertible, since it must always be recomputed from the current state of the genls heirarchy. For comparison, see nearestDifferentIsa."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestCommonSpecs,"(nearestCommonSpecs COL-1 COL-2 NEAR-SPEC) relates collections COL-1 and COL-2 to the nearest unsubsumed collections NEAR-SPEC of which are subsets of both COL-1 and COL-2. This predicate is notAssertible, since it must always be recomputed from the current state of the genls heirarchy. For comparison, see also nearestCommonIsa and nearestCommonGenls."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestCommonIsa,"(nearestCommonIsa THING1 THING2 NEAR-COL) means that NEAR-COL is a \"nearest\" collection of which both THING1 and THING2 are instances. That is, both (isa THING1 NEAR-COL) and (isa THING2 NEAR-COL) hold, and there is no reified Collection NEARER-COL distinct from NEAR-COL such that (isa THING1 NEARER-COL), (isa THING2 NEARER-COL) and (genls NEARER-COL NEAR-COL) all hold. Note that this predicate is non-assertible (see notAssertible), since its extension at any given time depends upon (and so must be computed from) the current state of the isa and genls hierarchies in the Cyc Knowledge Base. See also nearestCommonGenls and nearestCommonSpecs."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(nearestCommonGenls,"A TaxonomicPredicateForCollections that relates two collections to their nearest common generalizations represented in the Cyc Knowledge Base. (nearestCommonGenls COL1 COL2 NEAREST-GENL) means that (i) NEAREST-GENL in known in the Cyc Knowledge Base to subsume (via genls) both COL1 and COL2 and (ii) there is no proper specialization of NEAREST-GENL that is known to subsume both COL1 and COL2.\n

\nNote that nearestCommonGenls is not functional with respect to its third argument, as a pair of collections might have several nearest common generalizations, all orthogonal to each other. Note also that this predicate is notAssertible, since it must always be recomputed from the current state of the represented genls heirarchy. \n

\nSee also nearestCommonIsa and nearestCommonSpecs."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(natFunction,"(natFunction NAT FUNCTION) states that FUNCTION is the function used in the non-atomic term NAT. For example, (natFunction (JuvenileFn Dog) JuvenileFn). More precisely, (termOfUnit NAT (FUNCTION ...)) implies (natFunction NAT FUNCTION)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(natArgumentsEqual,"(natArgumentsEqual NAT1 NAT2) means that the\narguments of NAT1 and NAT2 unify. For example, (natArgumentsEqual (FemaleFn Dog) (MaleFn Dog). More precisely, (and (termOfUnit NAT1 (FUNCTION1 . ARGS)) (termOfUnit NAT2 (FUNCTION2 . ARGS))) implies (natArgumentsEqual NAT1 NAT2)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(natArgument,"(natArgument NAT N TERM) means that TERM is in the Nth argument position of the non-atomic term NAT. For example, (natArgument (JuvenileFn Dog) 1 Dog). Note that (termOfUnit NAT (FUNCTION ... ARGN ...)) implies (natArgument NAT N ARGN)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtVisible,"A unary EvaluatablePredicate that applies to a Microtheory. (mtVisible MT) means that the contents of MT are visible in the current query context. \n\nIn general, \n

\n(genlMt MT1 MT2) \n
\nentails \n
\n(ist MT1 (mtVisible MT2),\n
\nbut the converse does not hold. In particular, it fails when MT1 is a ProblemSolvingCntxt. For example, \n
\n(ist EverythingPSC (mtVisible HumanSocialLifeMt))\n
\nholds (in BaseKB), but\n
\n(genlMt EverythingPSC HumanSocialLifeMt)\n
\ndoes not hold (in BaseKB)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(means,"A MetaLanguagePredicate (q.v.) that relates SubLSExpressions to their meanings: the things in the intended model of the CycL language that those terms denote, refer to, stand for, or express. (means TERM THING) means that TERM denotes, refers to, stands for, or expresses THING. TERM will often be explicitly quoted, by being wrapped in the syncategorematic quotation symbol 'Quote'. For example, the true sentence '(means (Quote Plato) Plato)' means that the CycL term 'Plato' means (denotes) the person Plato. (Thus means's first argument-place is not \"implicitly quoted\"; cf. quotedArgument).\n

\nBut note that the first argument of means might not be quoted at all. Suppose (e.g.) that the term 'Plato' were the CycL constant most beloved of Cyclists, and that a new constant 'CyclistsFavoriteConstant' were reified and defined so as to reflect this fact. Then 'CyclistsFavoriteConstant' would denote the CycL constant 'Plato', which in turn denotes the man Plato; and so the sentence '(means CyclistsFavoriteConstant Plato)' -- which involves no quotation -- would be true.\n

\nNote finally that the sentence '(means Plato Plato)' is of course not true, as it means that the man Plato is a CycL term that denotes the man Plato, which is a patent falsehood since no man is a CycL term and no man denotes anything.\n

\nSee also expresses, denotes, hasDenotatum, quotedIsa, EscapeQuote, and the shared NoteAboutQuotingInCycL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(knownSentence,"A KBDependentRelation (q.v.) and specialization of trueSentence (q.v.) that is used to state that a given sentence is \"known\" to be true to the Cyc system. More precisely, (knownSentence SENT) means that SENT is provable by the Cyc inference engine from sentences currently in the Knowledge Base. knownSentence is a non-assertible predicate (see notAssertible). Note that this predicate is not to be confused with call_u_no_bc, which is used to state that a given sentence is explicitly asserted in the KB."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(knownAntecedentRule,"A MetaKnowledgePredicate that is used to state a strong pragmatic directive to the CycInferenceEngine. Asserting (knownAntecedentRule RULE) tells the inference engine to automatically generate a removal module to implement RULE; i.e. to solve queries unifying with the consequent of RULE by attempting to prove the substituted antecedent of RULE. When this removal module is used during inference, it attempts to prove the substituted antecedent via removal only (see knownSentence). It does not preclude other uses of RULE in inference."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(irrelevantMt,"A CycInferenceHeuristicRelevancePredicate. (irrelevantMt MT) means that all assertions made in the Microtheory MT should be heuristically considered very unlikely to be relevant to inferences done in the Microtheory MT-1 in which (irrelevantMt MT) is asserted (where MT-1 and MT need not be the same). As a consequence, note that when (irrelevantMt MT) is asserted in a Microtheory MT-1, each of the assertions in MT will be an irrelevantAssertion (q.v.) for inferences done in MT-1."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgResultIsaReln,"A quintary MetaRelation predicate for stating that a certain kind of complex, partly isa based relationship holds between a given argument to a given function and the corresponding value that is returned. (interArgResultIsaReln FUNC N RELATION RELATION-NAT-TERM-ARG RELATION-COLLECTION-ARG) means that, if there is a sentence asserted in the KB relating NAT-TERM and COLLECTION via RELATION and NAT-TERM is the RELATION-NAT-TERM-ARGth argument in the sentence and COLLECTION is the RELATION-COLLECTION-ARGth argument, then when NAT-TERM appears as the Nth argument to FUNC, then (regardless of what the other arguments to FUNC might be) the value (if any) of that function for those arguments is an instance of COLLECTION. That is: if (RELATION ... NAT_TERM ... COLLECTION ...) or (RELATION ... COLLECTION ... NAT_TERM ...) is an asserted sentence, and (FUNC ARG(1) ... ARG(N-1) NAT_TERM ...) = VALUE, then VALUE is an instance of COLLECTION. Obviously, COLLECTION must be a collection; so RELATION's RELATION-COLLECTION-ARGth argument-place is likely to be isa constrained (see argIsa) to Collection or some specialization thereof."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgResultGenlReln,"A quintary MetaRelation predicate for stating that a certain kind of complex, partly genls based relationship holds between a given argument to a given function and the corresponding value that is returned. (interArgResultGenlReln FUNC N RELATION RELATION-NAT-TERM-ARG RELATION-COLLECTION-ARG) means that, if there is a sentence asserted in the KB relating NAT-TERM and COLLECTION via RELATION and NAT-TERM is the RELATION-NAT-TERM-ARGth argument in the sentence and COLLECTION is the RELATION-COLLECTION-ARGth argument, then when NAT-TERM appears as the Nth argument to FUNC, then (regardless of what the other arguments to FUNC might be) the value (if any) of that function for those arguments is a subcollection of COLLECTION. That is: if (RELATION ... NAT_TERM ... COLLECTION ...) or (RELATION ... COLLECTION ... NAT_TERM ...) is an asserted sentence, and (FUNC ARG(1) ... ARG(N-1) NAT_TERM ...) = VALUE, then VALUE is a subcollection of COLLECTION. Obviously, COLLECTION must be a collection; so RELATION's RELATION-COLLECTION-ARGth argument-place is likely to be isa constrained (see argIsa) to Collection or some specialization thereof."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa,"A quintary instance of InterArgIsaPredicate (q.v.). (interArgIsa RELN INDEP-ARGNUM INDEP-COL DEP-ARGNUM DEP-COL) means that, when an instance of INDEP-COL appears as the INDEP-ARGNUMth argument to RELN, a necessary condition for semantic well-formedness is that the DEP-ARGNUMth argument must be an instance of DEP-COL. That is, if INDEP-INST is an instance of INDEP-COL, then (RELN ... INDEP-INST ...), where INDEP-INST is the INDEP-ARGNUMth (or \"independent\") argument to RELN, is semantically well-formed only if the DEP-ARGNUMth (or \"dependent\") argument (which is some item in the sequence <... INDEP-INST ...> other than the INDEP-ARGNUMth) is an instance of DEP-COL.\n

\nFor example, (interArgIsa performedBy 1 PurposefulAction 2 IntelligentAgent) means that, if ACT is a PurposefulAction, then (performedBy ACT AGENT) is semantically well-formed only if AGENT is an IntelligentAgent.\n

\nFor an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations. For a more general explanation of independent and dependent arguments in the present sense, see InterArgConstraintPredicate. For similar to but less flexible predicates than interArgIsa, which have already-fixed positions for the independent and dependent arguments, see the ternary interArgIsa1-2 et al."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgDifferent,"A MetaRelation used for stating a certain kind of necessary condition for being an element of the domain of a given Relation (see relationDomain). Thus (to put it in terms of the semantics of CycL expressions) interArgDifferent can be used for stating a certain kind of truth- or denotation-condition for a given relation-denoting expression. (interArgDifferent RELN N M) means that RELN (if it is a Predicate or other TruthFunction) only holds among or (if it is a Function-Denotational) only has a value for sequences of arguments whose Nth and Mth members are distinct (see different). That is (assuming without loss of generality that N < M): if RELN is a predicate or other \"truth-function\" then (RELN ... ARGN ... ARGM ...) holds only if ARGN and ARGM are distinct, and if RELN is a function then it is defined for (i.e. associates a value with) a sequence only if THING-N and THING-M are distinct. For example, (interArgDifferent opponentsInConflict 1 2) means that no-one is his or her own opponent in a conflict.\n

\nNote that this predicate trivially holds for any relation with respect those argument-places it has that are subject to mutually disjoint (see disjointWith and cf. cosatisfiableInArgs) argument-type constraints (see ArgTypePredicate)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(instanceElementType,"A binary FirstOrderCollectionPredicate that relates types of sets to the types of elements they have in common. More precisely, (instanceElementType SETTYPE COLLECTION) means that every elementOf every instance of (see isa) SETTYPE is an instance of COLLECTION. For example, both of these hold:\n

\n  (instanceElementType PointSet Point)\n\n  (instanceElementType Set-Mathematical Thing) . \n
\nSee the corresponding function SetOfTypeFn, which takes a given collection to the collection of all sets whose elements are instances of the former. And see typeGenls for a similar predicate that relates collections of collections (rather than collections of sets) to their common element types."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(indexicalReferent,"(indexicalReferent INDCONCEPT THING) means that in the context of the assertion, the IndexicalConcept INDCONCEPT has the referent THING. This is a StrictlyFunctionalSlot, in keeping with the idea that the predicate will return one and only one 'value' for the second argument place at any given point in context space. However, be advised that the arg2 will change from context to context."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(highlyRelevantAssertion,"A CycInferenceHeuristicRelevancePredicate. (highlyRelevantAssertion ASSERTION) states that the CycLAssertion ASSERTION should be heuristically considered highly relevant to inferences that are performed in a context in which (highlyRelevantAssertion ASSERTION) is visible. See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(genFormat,"The Common Lisp format string ARG2 can be applied to the argument list ARG3 to generate pseudo-English for the Cyc Relation ARG1"),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(formulaArity,"(formulaArity FORMULA INTEGER) means that the CycL formula FORMULA contains INTEGER arguments. See also FormulaArityFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(extentCardinality,"(extentCardinality SETORCOL N) means that there are N terms in the currently represented extent of SetOrCollection SETORCOL. See also cardinality."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(extConceptOverlapsColAndReln,"(extConceptOverlapsColAndReln COL RELN SOURCE STRING) means\nthat the external structured data source SOURCE variously uses the term\nnamed by STRING as a value that semantically maps to the Cyc Collection\nCOL, and as a slot that maps to the Cyc BinaryPredicate RELN."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(expresses,"A MetaLanguagePredicate (q.v.) and a specialization of means (q.v.) that relates a CycL sentence to the Proposition (if any) it expresses with respect to the intended model of the CycL language. (expresses SENTENCE PROPOSITION) means that SENTENCE expresses, or has as its intensional meaning, PROPOSITION.\nIn order to express a proposition (see CycLPropositionalSentence), a CycL sentence must at the very least be closed and obey the arity of its main operator.\n

\nFor example, the sentence\n

\n  (likesAsFriend Muffet Murray)\n
\nexpresses the proposition that Muffet likes Murray, and we can represent that fact as follows:\n
\n  (expresses\n    (Quote (likesAsFriend Muffet Murray))\n    (ThatFn (likesAsFriend Muffet Murray)))\n
\nNow the above sentence is of course nearly trivial, given the intimate connection that exists between the function ThatFn and the expresses relation. But, as we shall see, not all expresses sentences are trivial.\n

\nAs the example illustrates, the first argument-term in an expresses statement might consist of a particular CycL sentence wrapped with Quote. But note that this need not be the case. Suppose the above likesAsFriend sentence happened to be the first CycL assertion made by Muffet. We might then reify a constant named MuffetsFirstCycLAssertion to denote that sentence. Then we could say:\n

\n  (expresses\n    MuffetsFirstCycLAssertion\n    (ThatFn (likesAsFriend Muffet Murray)))\n
\nAs the example also illustrates, the second argument-term in an expresses statement might consist of a non-atomic term formed by applying the functor ThatFn to a particular CycL sentence. But this also need not be the case. Suppose the proposition that Muffet likes Murray happened to be Murray's favorite proposition. We might then reify a constant named MurraysFavoriteProposition to denote that proposition. Then we could say:\n
\n  (expresses\n    MuffetsFirstCycLAssertion\n    MurraysFavoriteProposition)\n
\nSee also denotes."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(exceptMt,"(exceptMt MT) means that (except ASSERTION) is true for all ASSERTIONs asserted in MT. In other words, in the current microtheory ASSERTION is not known to be true. If ASSERTION is a rule, it will not fire."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(except,"(except ASSERTION) means that there is an exception to ASSERTION in the current microtheory such that ASSERTION is not known to be true. If ASSERTION is a rule, it will not fire."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(exactlyAssertedEL_next,"A KBDependentRelation (q.v.) and specialization of call_u_no_bc (q.v.) that is used to state that a given CycLSentence-Assertible has been asserted in the KB (in some accessible Microtheory). More exactly, (exactlyAssertedEL_next SENT) is true in microtheory MT precisely when SENT canonicalizes without commutative handling of the sentence args into a set of clauses of the same form as the canonicalized form of some assertion in a microtheory accessible to MT. (The predicate is thus true both of assertions entered into the KB by hand and assertions deduced by Cyc from forward rules.)\n

\nThis predicate enables Cyc to select a subset of information when answering queries, filtering out more generic (asserted-without-commutative-canonicalization) information. Thus, for example, the query:\n

\n(call_u_no_bc (bordersOn CentralUSATimeZone EasternUSATimeZone))\n

\nwill return True (in appropriate microtheories), whereas:\n

\n(exactlyAssertedEL_next (bordersOn CentralUSATimeZone EasternUSATimeZone))\n

\nwill not."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(evaluationResultQuotedIsa,"A binary MetaRelation that holds between relations and collections. evaluationResultQuotedIsa is primarily used to indicate that any value returned by a given evaluatable function is a quoted instance of a given collection. Where FUNC is a Function-Denotational, (evaluationResultQuotedIsa FUNC COL) means that FUNC returns a quoted instance of COL for any sequence of arguments for which FUNC is defined. That is, (quotedIsa (FUNC ARG1 ... ARGn) COL) holds for any sequence for which FUNC has a value. For example, '(evaluationResultQuotedIsa SubstringFn SubLString)' holds, and it entails (e.g.) '(quotedIsa (SubstringFn \"ABC\" 1 2) SubLString)'."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ephemeralTerm,"(ephemeralTerm TERM) states that TERM is a term that only has meaning in this particular copy of the knowledge base. A such, it can be viewed as an ephemeral concept which could likely be forgotten at some future point in time, perhaps by an explicit 'forgetting' process. See also termDependsOn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(denotes,"A MetaLanguagePredicate (q.v.) that relates CycLDenotationalTerm to their denotata: the things in the intended model of the CycL language that those terms denote or stand for. (denotes TERM THING) means that TERM denotes THING. TERM will often be explicitly quoted, by being wrapped in the syncategorematic quotation symbol 'Quote'. For example, the true sentence '(denotes (Quote Plato) Plato)' means that the CycL term 'Plato' denotes the person Plato. (Thus denotes's first argument-place is not \"implicitly quoted\"; cf. quotedArgument).\n

\nBut note that the first argument of denotes might not be quoted at all. Suppose (e.g.) that the term 'Plato' were the CycL constant most beloved of Cyclists, and that a new constant 'CyclistsFavoriteConstant' were reified and defined so as to reflect this fact. Then 'CyclistsFavoriteConstant' would refer to the CycL constant 'Plato', which in turn denotes the man Plato; and so the sentence '(denotes CyclistsFavoriteConstant Plato)' -- which involves no quotation -- would be true.\n

\nNote also that not all CycL terms denote, not even all CycLClosedDenotationalTerms (q.v.). For example, the term '(BorderBetweenFn Canada Mexico)' fails to denote anything (except perhaps in certain counterfactual contexts).\n

\nNote finally that the sentence '(denotes Plato Plato)' is of course not true, as it means that the man Plato is a CycL term that denotes the man Plato, which is a patent falsehood since no man is a CycL term and no man denotes anything.\n

\nSee also means, expresses, hasDenotatum, quotedIsa, EscapeQuote, and the shared NoteAboutQuotingInCycL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(defaultReformulatorModePrecedence,"(defaultReformulatorModePrecedence PRIMARY-MODE\nSECONDARY-MODE TERTIARY-MODE ...), asserted in the microtheory MT,\nmeans that in MT or a specMt thereof (unless overridden),\nthe CycLReformulator will use PRIMARY-MODE as its primary mode,\nSECONDARY-MODE as its secondary mode, etc. This helps the\nreformulator establish precedence of CycLReformulatorDirectives.\nDo not specify both tersify and verbosify."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(defaultReformulationDirectionInModeForPred,"If the CycLReformulator is operating in MT in the mode MODE, and it\nencounters a reformulation rule with no reformulationDirectionInMode\nmeta-assertion for MODE stated in MT or a genlMt thereof, the extent of this\npredicate will be used to determine the reformulation direction of the\nrule."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(decontextualizedPredicate,"(decontextualizedPredicate PRED) states that PRED is a predicate which is context-independent. In effect, any use of PRED can be lifted into any microtheory. Predicates which are labelled with decontextualizedPredicate typically have an argument which either implicitly or explicitly provides the implied context. A good example of such a predicate is ist."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(decontextualizedCollection,"(decontextualizedCollection COL) states that COL is a collection in which membership is context-independent. In effect, any instance of COL is an instance of COL in every microtheory."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(cycTransformationProofRule,"(cycTransformationProofRule PROOF RULE) means that RULE is the rule used by PROOF to prove its proven query."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(cycTransformationProofBindings,"(cycTransformationProofBindings TRANSFORMATION-PROOF BINDING) means that BINDING is an InferenceBinding (using the appropriate variable from the transformation rule for TRANSFORMATION-PROOF) proven by TRANSFORMATION-PROOF."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(constantName,"(constantName CONSTANT STRING) means that the SubLString STRING is the \"name\" for the CycLConstant CONSTANT. That is, STRING is the string of characters that make up CONSTANT, minus the initial \"#\" and the following \"$\"."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(constantID,"A predicate which relates each Cyc constant to an internal identification number for it. This number is unique within any given image, though not necessarily across images (for that, see constantGUID). (constantID CONSTANT ID) states that the NonNegativeInteger ID is the unique internal id for the CycLConstant CONSTANT (in the current image). For obvious reasons, this predicate is notAssertible."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(constantGUID,"A strictly functional slot used to associate CycL constants with the GUID strings they are assigned. (constantGUID CONSTANT GUID-STR) means that the CycLConstant CONSTANT is associated with the GUIDString GUID-STR. The arg1 position of this predicate is \"quoted\", so, for example, (constantGUID Dog \"bd58daa0-9c29-11b1-9dad-c379636f7270\") means that the constant \"Dog\" itself, not the collection of dogs, is associated with the GUIDString \"bd58daa0-9c29-11b1-9dad-c379636f7270\"."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionIsaBackchainRequired,"(collectionIsaBackchainRequired COLLECTION)\n

\nmeans that rules that conclude\n

\n(isa COLLECTION)\n

\nmust be used in order to prove literals of the form\n

\n(isa COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. See also backchainRequired for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionIsaBackchainEncouraged,"

\n(collectionIsaBackchainEncouraged COLLECTION)\n

\nmeans that rules that conclude\n

\n(isa COLLECTION)\n

\nare most likely going to have to be used in order to prove literals of the form\n

\n(isa COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. Note that it will not necessarily use rules of the form\n

\n(isa )\n

\nwhere might bind to COLLECTION, and it will not necessarily use rules of the form\n

\n(isa SPEC),\n

\nwhere (genls SPEC COLLECTION).\n

\nSee also backchainEncouraged for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionGenlsBackchainRequired,"(collectionGenlsBackchainRequired COLLECTION)\n

\nmeans that rules that conclude\n

\n(genls COLLECTION)\n

\nmust be used in order to prove literals of the form\n

\n(genls COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. See also backchainRequired for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionGenlsBackchainEncouraged,"

\n(collectionGenlsBackchainEncouraged COLLECTION)\n

\nmeans that rules that conclude\n

\n(genls COLLECTION)\n

\nare most likely going to have to be used in order to prove literals of the form\n

\n(genls COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. Note that it will not necessarily use rules of the form\n

\n(genls )\n

\nwhere might bind to COLLECTION, and it will not necessarily use rules of the form\n

\n(genls SPEC),\n

\nwhere (genls SPEC COLLECTION).\n

\nSee also backchainEncouraged for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionExpansion,"(collectionExpansion COL FORMULA) states that membership\nof a term in the collection COL is equivalent to FORMULA involving\nthat term being true. The meta-variable :ARG1 is used to stand for\nthe term in FORMULA, and the meta-variable :ARG2 is used to stand for\nthe collection in FORMULA."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionConventionMt,"(collectionConventionMt COL MT) means that assertions of the form (isa INS COL), for any INS, are by convention asserted in MT."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionBackchainRequired,"(collectionBackchainRequired COLLECTION)\n

\nmeans that rules that conclude\n

\n(isa COLLECTION)\n

\nmust be used in order to prove literals of the form\n

\n(isa COLLECTION)\n

\nand rules that conclude\n

\n(genls COLLECTION)\n

\nmust be used in order to prove literals of the form\n

\n(genls COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. See also backchainRequired for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(collectionBackchainEncouraged,"

\n(collectionBackchainEncouraged COLLECTION)\n

\nmeans that rules that conclude\n

\n(isa COLLECTION)\n

\nare most likely going to have to be used in order to prove literals of the form\n

\n(isa COLLECTION),\n

\nand rules that conclude\n

\n(genls COLLECTION)\n

\nare most likely going to have to be used in order to prove literals of the form\n

\n(genls COLLECTION).\n

\nThis directs the inference engine to use such rules even if HL predicate transformation is disabled. Note that it will not necessarily use rules of the form\n

\n([isa|genls] )\n

\nwhere might bind to COLLECTION, and it will not necessarily use rules of the form\n

\n([isa|genls] SPEC), where (genls SPEC COLLECTION).\n

\nSee also backchainEncouraged for the analogue of this predicate applicable to predicates rather than collections."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(backchainRequired,"(backchainRequired PREDICATE) means that rules that conclude PREDICATE must be used in order to prove literals involving PREDICATE. In other words, when performing inferences, all literals involving PREDICATE must be eliminated using rules since there won't be any other way to prove them. See also backchainEncouraged, backchainDiscouraged, and backchainForbidden."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(backchainForbiddenWhenUnboundInArg,"backchainForbiddenWhenUnboundInArg is a predicate that\nallows users to prevent the inference engine from backchaining on a\nliteral when one or more of its arguments are unbound. That is, if\nPRED is a Predicate, N a positive integer less than or equal to the\narity of PRED, then (backchainForbiddenWhenUnboundInArg PRED N) that\nno rules concluding to a positive literal with PREDICATE as the arg0\n(in other words, no implies assertions in which a literal with\nPREDICATE as the arg0 appears in the consequent) will be used when\nattempting to prove (non-negated) literals with PREDICATE as the arg0\n*unless* argN in the literal is fully bound. For instance, the sentence\n

\n(backchainForbiddenWhenUnboundInArg interestingSentence 1)\n
\nprevents the inference engine from applying any rule concluding\ninterestingSentence, such as \n
\n(implies\n  (maleficiary ?PROGRAM ?AGENT) \n  (interestingSentence ?AGENT (maleficiary ?PROGRAM ?AGENT)))\n
\nunless and until ?AGENT is bound."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(backchainForbidden,"backchainForbidden is a predicate that allows users to cut down on the number of rules used to prove certain literals, and thus to increase the speed of inferences that involve proving those literals. (backchainForbidden PREDICATE) means that no rules containing a positive literal with PREDICATE as the arg0 (in other words, no implies assertions in which a literal with PREDICATE as the arg0 appears in the consequent) will be used when attempting to prove (non-negated) literals with PREDICATE as the arg0. Asserting (backchainForbidden PREDICATE) is useful when all (non-negated) literals with PREDICATE as the arg0 are expected to be solvable by lookup of ground atomic formulas (GAF's) already in the KB, and so rules won't be needed to prove them. However, asserting (backchainForbidden PREDICATE) is usually counter-productive in contexts where some literals with PREDICATE as the arg0 are expected to be proven via backchaining on rules containing a positive literal with PREDICATE as the arg0. See also the related predicates backchainRequired, backchainEncouraged, and backchainDiscouraged."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(assertionUtility,"A CycInferenceHeuristicRelevancePredicate. (assertionUtility ASSERTION NUM) states that the CycLAssertion ASSERTION should be heuristically considered of utility NUM to inferences made in the current Microtheory. NUM should be a RealNumber between 1 and -1, with 1 indicating maximum utility, -1 indicating minimum utility, and 0 being agnostic with respect to utility. (assertionUtility ASSERTION 1) is equivalent to (highlyRelevantAssertion ASSERTION). (assertionUtility ASSERTION -1) is equivalent to (irrelevantAssertion ASSERTION). See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(assertionDirection,"An AssertionDescriptorPredicate that \nis used to state that a given CycLAssertion has a certain inference \n\"direction\", which indicates something about how and when the assertion \ncan be used in inferences by the Cyc system. (assertionDirection ASSERTION DIRECTION) means that ASSERTION has DIRECTION as its CycLAssertionDirection (q.v.). DIRECTION is normally Backward-AssertionDirection (q.v.) when \nASSERTION is a rule and Forward-AssertionDirection (q.v.) when ASSERTION is \na ground atomic formula (or \"GAF\"; see CycLClosedAtomicSentence). Note \nthat a CycL sentence is given a direction at the time of its assertion to the \nKnowledge Base, and this fact _need_not_ in general be reflected in another, \nassertionDirection GAF's being asserted (as that would of course lead to an infinite regress)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(assertedTermSentences,"(assertedTermSentences THING SENTENCE) means that SENTENCE has been asserted to the Cyc Knowledge Base (and is thus a CycLAssertion) and that THING is mentioned in SENTENCE. More precisely, and assuming the assertedTermSentences formula contains no free variables (and \nis thus a \"ground atomic formula\" or \"GAF\"): the CycL term immediately following the constant `assertedTermSentences' in the formula occurs in SENTENCE. For example, (assertedTermSentences France (bordersOn France Germany)) holds. See also call_u_no_bc and assertedPredicateArg for related predicates about assertions; and see termFormulas for a more general predicate that does not entail that SENTENCE has been asserted."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(assertedPredicateArg,"(assertedPredicateArg OBJ N PREDICATE) means that a ground atomic formula (or \"GAF\"; see CycLClosedAtomicSentence) whose initial (or \"0th\" argument-place) term denotes PREDICATE, and whose Nth argument-place term denotes OBJ, is asserted in the Cyc Knowledge Base. Note that this predicate is itself notAssertible (q.v.), since it must be computed from the state of the knowledge base."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(argsQuotedIsa,"A binary ArgQuotedIsaPredicate (q.v.) that is used to put a specified quoted-isa based argument-type constraint on all of a given relation's argument-places at once. (argsQuotedIsa RELN COL) means that semantic well-formedness requires that each argument to which RELN is applied (regardless of argument-place) be a quoted instance of COL. For example, '(argsQuotedIsa and CycLSentence-Assertible)' means that the relation and must only be applied to assertible CycL sentences. argsQuotedIsa is particularly useful for constraining (any and all of) the arguments of a VariableArityRelation (the preceding example being a case in point); though argQuotedIsa may be applied to fixed-arity relations as well. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its immediate specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(argQuotedIsa,"A ternary Predicate (argQuotedIsa RELN N COL) means that semantic well-formedness requires that the term given as the Nth argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ... ARGN ...) is semantically well-formed only if (quotedIsa ARGN COL) holds. For example, (argQuotedIsa examplePredSentences 1 CycLSentence) holds. "),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(argIsa,"A ternary ArgIsaPredicate (q.v.). (argIsa RELN N COL) means that semantic well-formedness requires that anything given as the Nth argument to RELN must be an instance of COL. That is, (RELN ... ARGN ...) is semantically well-formed only if (isa ARGN COL) holds. For example, (argIsa mother 1 Animal) and (argIsa argIsa 3 Collection) both hold. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. For similar but less flexible binary predicates, see arg1Isa et al. See also argGenl."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg6SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg6SometimesIsa\nRELATION COLLECTION) means that semantic well-formedness requires that\nanything given as the sixth argument to RELATION must be an\ninstance of COLLECTION at some time. More precisely, if\n(arg6SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ... ARG6 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG6 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg6QuotedIsa,"A binary Predicate (arg6QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the sixth argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 ...) is semantically well-formed only if (quotedIsa ARG6 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg6Isa,"A binary ArgIsaPredicate (q.v.). (arg6Isa RELN COL) means that semantic well-formedness requires that anything given as the sixth argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 ...) is semantically well-formed only if (isa ARG6 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg6Genl,"A binary ArgGenlPredicate (q.v.). (arg6Genl RELN COL) means that semantic well-formedness requires that anything given as the sixth argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ARG6 ...) is semantically well-formed only if (genls ARG6 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg5SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg5SometimesIsa\nRELATION COLLECTION) means that semantic well-formedness requires that\nanything given as the fifth argument to RELATION must be an\ninstance of COLLECTION at some time. More precisely, if\n(arg3SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ... ARG5 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG5 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg5QuotedIsa,"A binary Predicate (arg5QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the fifth argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ...) is semantically well-formed only if (quotedIsa ARG5 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg5Isa,"A binary ArgIsaPredicate (q.v.). (arg5Isa RELN COL) means that semantic well-formedness requires that anything given as the fifth argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ...) is semantically well-formed only if (isa ARG5 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg5Genl,"A binary ArgGenlPredicate (q.v.). (arg5Genl RELN COL) means that semantic well-formedness requires that anything given as the fifth argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ARG5 ...) is semantically well-formed only if (genls ARG5 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg4SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg4SometimesIsa\nRELATION COLLECTION) means that semantic well-formedness requires that\nanything given as the fourth argument to RELATION must be an\ninstance of COLLECTION at some time. More precisely, if\n(arg3SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ... ARG4 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG4 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg4QuotedIsa,"A binary Predicate (arg4QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the fourth argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ...) is semantically well-formed only if (quotedIsa ARG4 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg4Isa,"A binary ArgIsaPredicate (q.v.). (arg4Isa RELN COL) means that semantic well-formedness requires that anything given as the fourth argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ...) is semantically well-formed only if (isa ARG4 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg4Genl,"A binary ArgGenlPredicate (q.v.). (arg4Genl RELN COL) means that semantic well-formedness requires that anything given as the fourth argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ARG4 ...) is semantically well-formed only if (genls ARG4 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg3SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg3SometimesIsa\nRELATION COLLECTION) means that semantic well-formedness requires that\nanything given as the third argument to RELATION must be an\ninstance of COLLECTION at some time. More precisely, if\n(arg3SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ... ARG3 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG3 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg3QuotedIsa,"A binary Predicate (arg3QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the third argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ARG2 ARG3 ...) is semantically well-formed only if (quotedIsa ARG3 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg3Isa,"A binary ArgIsaPredicate (q.v.). (arg3Isa RELN COL) means that semantic well-formedness requires that anything given as the third argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ARG3 ...) is semantically well-formed only if (isa ARG3 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg3Genl,"A binary ArgGenlPredicate (q.v.). (arg3Genl RELN COL) means that semantic well-formedness requires that anything given as the third argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ARG3 ...) is semantically well-formed only if (genls ARG3 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg2SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg2SometimesIsa\nRELATION COLLECTION) means that semantic well-formedness requires that\nanything given as the second argument to RELATION must be an\ninstance of COLLECTION at some time. More precisely, if\n(arg2SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ... ARG2 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG2 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg2QuotedIsa,"A binary Predicate (arg2QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the second argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ARG2 ...) is semantically well-formed only if (quotedIsa ARG2 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg2Isa,"A binary ArgIsaPredicate (q.v.). (arg2Isa RELN COL) means that semantic well-formedness requires that anything given as the second argument to RELN must be an instance of COL. That is, (RELN ARG1 ARG2 ...) is semantically well-formed only if (isa ARG2 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg2Genl,"A binary ArgGenlPredicate (q.v.). (arg2Genl RELN COL) means that semantic well-formedness requires that anything given as the second argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ARG2 ...) is semantically well-formed only if (genls ARG2 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg1SometimesIsa,"An ArgSometimesIsaPredicate and ArgTypeBinaryPredicate, (arg1SometimesIsa RELATION\nCOLLECTION) means that semantic well-formedness requires that anything\ngiven as the first argument to RELATION must be an instance of\nCOLLECTION at some time. More precisely, if\n(arg1SometimesIsa RELATION COLLECTION) holds then in order to\nassert (RELATION ARG1 ...), it must only be the case that there\nexists some time interval (including Always-TimeInterval) in which\n(isa ARG1 COLLECTION) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg1QuotedIsa,"A binary Predicate (arg1QuotedIsa RELN COL) means that semantic well-formedness requires that the term given as the first argument to RELN must be an instance of the SubLExpressionType COL. That is, (RELN ARG1 ...) is semantically well-formed only if (quotedIsa ARG1 COL) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg1Isa,"A binary ArgIsaPredicate (q.v.). (arg1Isa RELN COL) means that semantic well-formedness requires that anything given as the first argument to RELN must be an instance of COL. That is, (RELN ARG1 ...) is semantically well-formed only if (isa ARG1 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argIsa for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(arg1Genl,"A binary ArgGenlPredicate (q.v.). (arg1Genl RELN COL) means that semantic well-formedness requires that anything given as the first argument to RELN must be a subcollection of COL. That is, (RELN ARG1 ...) is semantically well-formed only if (genls ARG1 COL) holds. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations. See argGenl for a similar but more flexible ternary predicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(afterRemoving,"When a gaf is unasserted, afterRemovings are called on the gaf dependent on the predicate of the gaf. (afterRemoving PRED HOOK) means that HOOK will be called on gaf whose predicate is PRED. If the gaf predicate has multiple afterRemovings, the order of execution is not guaranteed. Also, afterRemovings are retriggered on the removal of each of the arguments to a gaf."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(afterAdding,"Whenever a gaf is asserted, afterAddings are called on the gaf dependent on the predicate of the gaf. (afterAdding PRED HOOK) means that HOOK will be called on gaf whose predicate is PRED. If the gaf predicate has multiple afterAddings, the order of execution is not guaranteed. Also, afterAddings are retriggered on the addition of new arguments to an existing gaf."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(admittedSentence,"(admittedSentence SENTENCE) states that SENTENCE is a CycLSentence which is both syntactically and semantically well-formed with respect to argument constraints only. For example, (admittedSentence (bordersOn Canada France)) is true in WorldGeographyDualistMt, but not in WorldGeographyMt, since Canada and France are known to be instances of GeographicalRegion in the former microtheory, but not in the latter microtheory. See also admittedArgument."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(admittedNAT,"(admittedNAT NAT) states that NAT is a CycLNonAtomicTerm which is both syntactically and semantically well-formed wrt arg constraints. For example, (admittedNAT (MotherFn Muffet)) is true precisely in those mts in which Muffet satisfies all the applicable arg1 constraints imposed by MotherFn. See also admittedSentence."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(admittedArgument,"A ternary MetaRelation predicate that is used to state that a given thing meets the argument-type constraints on a given argument-place of a given relation. (admittedArgument THING ARGNUM RELN) means that THING satisfies all of the (single-argument) argument-type constraints (see ArgIsaPredicate and ArgGenlPredicate) for the ARGNUM-th argument position of RELN. \n

\nFor example, both of the following sentences hold:\n

  (admittedArgument AbrahamLincoln 1 wife)\n\n  (admittedArgument Cougar 1 JuvenileFn) .
\nSee also admittedAllArgument and admittedSentence."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(admittedAllArgument,"A ternary MetaRelation predicate that relates a Collection to an integer (representing an argument-place) to a Relation such that every instance of the collection is an admittedArgument (q.v.) to the specified argument-place of the relation. (admittedAllArgument COL ARGNUM RELN) means that every instance of COL satisfies all of the (single-argument) argument-type constraints (see ArgIsaPredicate and ArgGenlPredicate) for the ARGNUMth argument position of RELN. Note that COL is required not to be an EmptyCollection.\n

\nFor example, (admittedAllArgument FemaleHuman 1 spouse) and (admittedAllArgument PersonTypeByActivity 1 JuvenileFn) both hold."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tWFFSupportedTerm,"The collection of all CycLTerms that have some kind of special support in the CycWellFormednessChecker."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtWFFSupportedPredicate,"The collection of all Predicates that are supported in some way by the CycWellFormednessChecker, either to satisfy, impose, or relax well-formedness constraints."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtWFFDirectivePredicate,"The collection of all Predicates which can affect what WFF standards to impose on a given sentence."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtWFFConstraintSatisfactionPredicate,"The collection of all Predicates which can satisfy well-formedness constraints. More specifically, only assertions of the form (PRED . ARGS), where PRED is an instance of WFFConstraintPredicate, can directly satisfy a well-formedness constraint, i.e. cause any previously ill-formed sentence to become well-formed, given the same WFF standards. Any assertion could _indirectly_ satisfy a well-formedness constraint, for instance by triggering a forward rule or an afterAdding. A common case of this is the afterAddings on spec-preds of isa and genls."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtWFFConstraintPredicate,"The collection of all Predicates which can impose well-formedness constraints. More specifically, only assertions of the form (PRED . ARGS), where PRED is an instance of WFFConstraintPredicate, can directly impose a well-formedness constraint, i.e. cause a previously well-formed sentence to become ill-formed, given the same WFF standards. Any assertion could _indirectly_ impose a well-formedness constraint, for instance by triggering a forward rule or an afterAdding."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vWednesday,"A collection of CalendarDays and an \ninstance of DayOfWeekType. Wednesday is the collection of all \n(and only) wednesdays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(iUniversalVocabularyMt,"This is the microtheory which contains the 'definitional' assertions about everything in Cyc's universe of discourse. Definitional assertions about a concept are those which are intrinsic to the concept's nature and cannot be violated in any context."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(xUncanonicalizerAssertionFn,"UncanonicalizerAssertionFn is used by the CycUncanonicalizer and should rarely (if ever) need to be seen by users or referenced in assertions entered at the EL level. It is used by the uncanonicalizer to denote an CycLAssertion after it is transformed to its canonical EL formula."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtUnaryRelation,"The collection of all fixed-arity relations of arity 1 (see arity). The most notable specializations of UnaryRelation are UnaryPredicate and UnaryFunction (qq.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vTuesday,"A collection of CalendarDays and an \ninstance of DayOfWeekType. Tuesday is the collection of all \n(and only) tuesdays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vtTruthValue,"TruthValue is a collection of mathematical objects; it contains the abstract, logical objects True and False."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtTransformationModuleSupportedPredicate,"The collection of all Predicates which are supported by some CycTransformationModule."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ttTransformationModuleSupportedCollection,"The collection of all Collections which are supported by some CycTransformationModule."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vThursday,"A collection of CalendarDays and an instance of DayOfWeekType. Thursday is the collection of all (and only) thursdays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtTernaryRelation,"The collection of all fixed-arity relations of arity 3 (see arity). The most notable specializations of TernaryRelation are TernaryPredicate and TernaryFunction (qq.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vSunday,"A collection of CalendarDays and an instance of DayOfWeekType. Sunday is the collection of all (and only) sundays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(substringCaseinsensitive,"(substring-CaseInsensitive SUBSTRING STRING) means that the CharacterString SUBSTRING is a substring of the CharacterString STRING with case ignored in both SUBSTRING and STRING. For case-sensitive tagging use the more specialized predicate, substring."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uSubLQuoteFn,"(SubLQuoteFn SUBL-EXPRESSION) is one of exactly two escapes to SubL from CycL, the other being ExpandSubLFn. These are the only two ways to represent arbitrary SubL in CycL. SubLQuoteFn encapsulates SUBL-EXPRESSION such that it will not be rejected by the CycL wff-checker as ill-formed CycL. For example, (SubLQuoteFn (+ 1 2)), which is a CycLExpression, denotes the SubLSExpression (+ 1 2), which itself is not a CycLExpression."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ttExpressionType,"A collection of collections. Each instance of SubLExpressionType is a type (i.e. a subcollection) of SubLSExpression."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vtScalarInterval,"A specialization of TupleOfIntervals (q.v.). Roughly put, this is the collection of all things that can be ranked according to some one-dimensional scale. Instances of ScalarInterval are numbers or quantities possessing only sign and magnitude. They are construed as one-tuples (see Tuple) of intervals. They are to be contrasted with VectorIntervals (q.v.), which possess a direction as well as a magnitude, and are construed as two-membered tuples of intervals.\n

\nScalarInterval is partitioned into the two collections NumericInterval (which is the collection of numbers and number-ranges of all kinds) and Quantity (qq.v). A Quantity is usually specified with a numeric-interval, as with (Meter 3)), but it might also be given in a generically-ranked way, as with (HighAmountFn Happiness); see the specializations MeasurableQuantity and NonNumericQuantity. The magnitude of a scalar might be given by a specific number (see ScalarPointValue) or by a proper range of numbers (see ScalarProperInterval).\n

\nNote that the instances of MathematicalFunctionOnScalars (q.v.), which include artithmetic functions such as addition (see PlusFn) and division (see QuotientFn), are defined broadly so as to apply not only to numbers, but to (numerically-measured) scalar intervals generally. Thus (PlusFn (Meter 3) (Meter 5)) is equal to (Meter 8)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vtScalarIntegralValue,"A specialization of ScalarPointValue (q.v.). Each instance of ScalarIntegralValue is either an Integer or a MeasurableQuantity (q.v.) that is the value returned when some UnitOfMeasure (q.v.) function is applied to an Integer. In the latter case, the quantity is said to be \"integral with respect to\" that unit-of-measure (see integralWRTUnit).\n

\nFor example, both 6 and (Inch 6) are scalar integral values. The latter is integral with respect to Inch.\n

\nScalarIntegralValues are the admitted arguments for, and the values returned by, GreatestCommonDivisorFn and LeastCommonMultipleFn (qq.v.).\n

\nNote that, despite appearances to the contrary, (Foot-UnitOfMeasure 0.5) is a scalar integral value that is integral with respect to Inch, as it is equal to the scalar integral (Inch 6). It might even be argued that, in principle, every MeasurableQuantity is integral with respect to some (reified or not) unit-of-measure or other. But that is a contentious issue on which we need not take sides."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vSaturday,"A collection of CalendarDays and an \ninstance of DayOfWeekType. Saturday is the collection of all \n(and only) saturdays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tRuleTemplate,"Terms denoting formulas (typically without support for efficient inference) that can be (partially) instantiated as Cyc assertions (typically with support for efficient inference); see trueRule and ruleTemplateAssertion."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtRemovalModuleSupportedPredicateSpecific,"The collection of all Predicates which are supported by some CycRemovalModule-Specific. Sentences of the form (PRED . ARGS), where PRED is an instance of RemovalModuleSupportedPredicate-Specific, have special inference support."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtRemovalModuleSupportedPredicateGeneric,"The collection of all Predicates which are supported by some CycRemovalModule-Generic. An assertion of the form (PRED . ARGS), where PRED is an instance of RemovalModuleSupportedPredicate-Generic, may affect the provability of sentences other than just sentences whose predicate is PRED. This is what is meant by 'generic' in this sense."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ttRemovalModuleSupportedCollectionGeneric,"The collection of all Collections which are supported by some CycRemovalModule-Generic. An assertion of the form (isa INS COL), where COL is an instance of RemovalModuleSupportedCollection-Generic, may affect the provability of sentences that do not mention COL explicitly. In particular, it may affect the provability of sentences mentioning INS."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uRelationInstanceExistsFn,"(relationInstanceExists PRED THING COLL) says that THING stands in the relation PRED to some (not necessarily known) instance of the Collection COLL. (RelationInstanceExistsFn PRED THING COLL) denotes this instance of COLL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uRelationExistsInstanceFn,"(relationExistsInstance PRED COLL THING) says that some (not necessarily known) instance INS of the Collection COLL stands in the relation PRED to THING. (RelationExistsInstanceFn PRED COLL THING) denotes INS."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uRelationExistsAllFn,"The predicate relationExistsAll states that for every instance of a collection, some other term exists in a certain relationship. An arbitrary such term is a function of the instance, the predicate, the collection, and the type of the other term. (RelationExistsAllFn TERM PRED DEP-COL INDEP-COL) allows one to denote this `arbitrary such term that so exists' in a named fashion."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uRelationAllExistsFn,"An IndeterminateTermDenotingFunction (q.v.) that is closely related to relationAllExists. If both (relationAllExists PRED INDEP-COL DEP-COL) and (isa INDEP-INS INDEP-COL) hold, then (PRED INDEP-INS (RelationAllExistsFn INDEP-INS PRED INDEP-COL DEP-COL) also holds. Thus the term '(RelationAllExistsFn INDEP-INS PRED INDEP-COL DEP-COL)' \"indeterminately denotes\" some instance of DEP-COL that is related to INDEP-INS by PRED. For instance, since (relationAllExists citizens Country Person) and (isa Malaysia Country) both hold, so does (citizens Malaysia (RelationAllExistsFn Malaysia citizens Country Person))."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tReformulatorIrrelevantFORT,"The collection of Cyc FORTs that are not relevant to the reformulator."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tReformulatorHighlyRelevantFORT,"The collection of Cyc FORTs that are highly relevant to the reformulator."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tReformulatorHighlyRelevantFORT,"The collection of Cyc FORTs that are highly relevant to the reformulator. An example of such a FORT would be one that is referenced in a large number of reformulator rules in the KB (see intances of CycLReformulationRulePredicate)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtReformulatorDirectivePredicate,"The collection of Predicates which can affect the\nbehaviour of the CycLReformulator or its submodules. When\nreformulator directive GAFs are asserted, they are only relevant to\nthe reformulator when it is reformulating expressions in the\nmicrotheory in which the directive is asserted, or a specMt thereof."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(xQuoteFn,"The symbol 'Quote' is used in CycL as a device for referring to particular CycL expressions, in much the same way that quotation marks are often used in English in order to \"mention\" (rather than simply \"use\") an English word or phrase. (And in much the same way that single-quotes are used in the preceding sentence in order to refer to a particular CycL symbol.) If EXPR is a CycL expression, the term (Quote EXPR) -- formed by writing 'Quote' followed by EXPR and enclosing the result in parentheses -- is interpreted as denoting EXPR itself, as opposed to whatever it is (if anything) that EXPR ordinarily denotes (i.e. what it denotes when not inside the scope of Quote or in a quotedArgument position). For example, while the CycL constant Plato denotes a certain Greek philosopher, the compound expression (Quote Plato) denotes the term Plato itself. Similarly, the expression (Quote ?X) denotes the variable ?X, and the expression (Quote (isa Plato Philosopher)) denotes the sentence (isa Plato Philosopher).\n

\nQuote is also used in conjunction with the symbol EscapeQuote (q.v.), as a device for making general statements about CycL expressions. Let EXPR = (E1...En) be a well-formed CycL expression whose n immediate constituents are the CycL expressions E1, ..., and En (where n >= 1). The expression \n

\n  (Quote EXPR) = (Quote (E1...En))\n
\n-- consisting of the symbols Quote, EXPR, and a surrounding pair of parentheses -- is a term that denotes EXPR. The expression (call it EQ) \n
\n  (Quote (E1...(EscapeQuote Ei) ...En)\n
\n(where 1 <= i <= n) is a term whose meaning is similar to (Quote EXPR), except that any free occurrence of a variable in Ei remains free with respect to EQ as a whole. If Ei contains no free variables, then EQ is a closed term (see CycLClosedDenotationalTerm) that denotes EXPR, and is equivalent to (Quote EXPR). If Ei does contain free variables, then EQ is an open term (see CycLOpenDenotationalTerm) in which exactly the same variables occur free; and any closed instantiation of EQ denotes the corresponding instantiation of EXPR. (A closed instantiation of an open expression is any closed expression that results from simultaneously replacing each free occurrence of a variable in the open expression with some closed term, replacing any two occurrences of the same variable by the same closed term.)\n

\nFor a simple example, the variable ?X occurs free in the term\n

\n  (Quote (EscapeQuote (MotherFn ?X)) ;\n
\nand one instantiation of this is the closed term\n
\n  (Quote (EscapeQuote (MotherFn Plato)) ,\n
\nwhich denotes the non-atomic term (MotherFn Plato). \n

\nFor a more interesting example, consider a case where some but not all of the free variables in a term are quoted. In the expression\n

\n  (Quote (loves (EscapeQuote ?X) ?Y))\n
\nonly ?X occurs free -- the ?Y is quoted. Thus this instantiation of the above:\n
\n  (Quote loves (EscapeQuote Plato) ?Y)\n
\nis a closed term that denotes the open formula (loves Plato ?Y). \n

\nNote that the sort of quotation done in the first example above can also be done -- and done more elegantly -- using just QuasiQuote instead of Quote and EscapeQuote. But the sort of quotation done in the second example cannot be accomplished with QuasiQuote.\n

\nSee also QuasiQuote, EscapeQuote, denotes, quotedIsa, quotedArgument, NoteAboutQuotingInCycL, and NoteAboutSyncategorematicSymbols."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtQuintaryRelation,"The collection of all fixed-arity relations of arity 5 (see arity). The most notable specializations of QuintaryRelation are QuintaryPredicate and QuintaryFunction (qq.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtQuaternaryRelation,"The collection of all fixed-arity relations of arity 4 (see arity). The most notable specializations of QuaternaryRelation are QuaternaryPredicate and QuaternaryFunction (qq.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtQuaternaryFunction,"A specialization of both FixedArityFunction and QuaternaryRelation (qq.v.). Each instance of QuaternaryFunction is a function that always takes four arguments at a time, i.e. has the arity (see arity) 4."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(xQuasiQuoteFn,"A quotation device for making general statements about CycL expressions. QuasiQuote allows for any free variables occurring inside an expression to which it is applied to \"escape\" (i.e. remain free with respect to) the quotation. It is thus similar in function to, though less flexible than, the combination of Quote and EscapeQuote (qq.v.).\n

\nTo be more precise: the syncategorematic symbol QuasiQuote is a device for allowing genuinely free variables to occur inside quoted expressions, in order that one may meaningfully \"quantify into\" such expressions and thereby generalize over them. It can thus be instructively compared to the symbol Quote (q.v.), which is used to make statements about particular CycL expressions. Let EXPR be a well-formed CycL expression. The expression (Quote EXPR) -- consisting of the symbols Quote, EXPR, and a surrounding pair of parentheses -- is a term that denotes EXPR. The expression (QuasiQuote EXPR) is a term whose meaning is similar to (Quote EXPR), except that any free occurrence of a variable in EXPR remains free with respect to (QuasiQuote EXPR) as a whole. If EXPR contains no free variables, then (QuasiQuote EXPR) is a closed term (see CycLClosedDenotationalTerm) that denotes EXPR, and is equivalent to (Quote EXPR). If EXPR contains any free occurrences of variables, then (QuasiQuote EXPR) is an open term (see CycLOpenDenotationalTerm) in which exactly the same variables occur free; and any closed instantiation of (QuasiQuote EXPR) denotes the corresponding instantiation of EXPR. (A closed instantiation of EXPR is any closed expression that results from replacing each free occurrence of a variable in EXPR with some closed term, and replacing any two occurrences of the same variable by the same closed term.)\n

\nFor an example, the variable ?X occurs free in the term\n

\n  (QuasiQuote (MotherFn ?X)) ;\n
\nand one instantiation of this is the closed term\n
\n  (QuasiQuote (MotherFn Plato)) ,\n
\nwhich denotes the non-atomic term (MotherFn Plato). And the (implicitly quantified) rule\n
\n  (isa (QuasiQuote (MotherFn ?X)) CycLNonAtomicTerm)\n
\nmeans, in effect, that any closed instantiation of the open term (MotherFn ?X) -- e.g. (MotherFn Plato) -- is a non-atomic term of CycL.\n

\nSee also denotes, quotedIsa, quotedArgument, NoteAboutQuotingInCycL, and NoteAboutSyncategorematicSymbols."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtProblemSolvingCntxt,"A specialization of Microtheory.\nProblemSolvingCntxts are microtheories that are used to reason about \nparticular situations. Queries posed in ProblemSolvingCntxts are\nexpected to draw -- via the genlMt relation -- on a large number\nof other microtheories. A ProblemSolvingCntxt is usually created \nfor temporary use with a problem at hand, and is discarded after the \nproblem is dealt with. In contrast, a GeneralMicrotheory (q.v.), e.g., \nis created for lasting use. Specializations of ProblemSolvingCntxt \ninclude ParsingContext and ScenarioTestingMicrotheory."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtMtUnionFn,"(MtUnionFn . MTS) denotes the ProblemSolvingCntxt where each of MTS and all of their genlMts are relevant. This microtheory effectively contains all of the assertions from all of MTS, regardless of any contradictions."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtMtTimeWithGranularityDimFn,"An unreifiable BinaryFunction that takes a TimeInterval and a TimeParameter and returns a TemporalMicrotheory. (ist (MtTimeWithGranularityDimFn INTERVAL PAR) ASSERTION) holds just in case ASSERTION holds at INTERVAL to granularity PAR. See also MtTimeDimFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtMtTimeDimFn,"An unreifiable UnaryFunction that takes a TimeInterval and returns a TemporalMicrotheory. (ist (MtTimeDimFn INTERVAL) ASSERTION) holds just in case ASSERTION holds at INTERVAL to granularity Null-TimeParameter. See also MtTimeWithGranularityDimFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(mtMtSpaceFn,"(MtSpace MT-1 ... MT-N) denotes the microtheory whose set of domain assumptions is the union of the assertions true in each of MT-1 ... MT-N. Consequently, (MtSpace MT-1 ... MT-N) has each of MT-1 ... MT-N as one of its genlMts. Typically, but not always, there will be assertions true in (MtSpace MT-1 ... MT-N) that are not true in any of its genlMts. For example,\n

\n(MtSpace WorldHistoryMt (MtDim mtTimeIndex (YearFn 1790)))\n

\ndenotes the microtheory whose domain assumption are precisely those of the WorldHistoryMt (whose basic assumption is that we are in the context of actual world history) and those of the microtheory (MtDim mtTimeIndex (YearFn 1790)) (whose basic assumption is that 1790 is the present year -- see MtDim). The conjunction of these domain assumptions implies everything that is true in real world history in the year 1790. For example, these domain assumptions imply that (president UnitedStatesOfAmerica GeorgeWashington) is true. Consequently, this assertion is true in (MtSpace WorldHistoryMt (MtDim mtTimeIndex (YearFn 1790)))."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vMonday,"A collection of CalendarDays and an \ninstance of DayOfWeekType. Monday is the collection of all \n(and only) mondays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vModuloFn,"A binary function that takes a scalar and a comparable (non-null) point-value scalar to another comparable scalar, ModuloFn is a generalization of a basic notion of modular arithmetic, broadened to apply to ScalarIntervals of all sorts.\n

\n(ModuloFn SCALAR BASE) is the value of SCALAR modulo BASE, determined as follows. (i) If SCALAR and BASE are both positive or both negative values, SCALAR-MOD-BASE is the remainder left when BASE is successively subtracted from SCALAR (zero or more times) until the result is a value that is closer to the comparable null-value (see ScalarNullValue) than BASE is. (ii) If SCALAR and BASE differ in their numeric signs, SCALAR-MOD-BASE is the remainder left when BASE is successively added to SCALAR (zero or more times) until the result is a value whose numeric sign agrees with that of BASE or is null, and which is closer to the comparable null-value than BASE is. (iii) If SCALAR is already a null-value, SCALAR-MOD-BASE is just SCALAR itself. \n

\nFor example, (ModuloFn 8 3) = 2, (ModuloFn (Meter 9) (Meter -4)) = (Meter -3), and (ModuloFn (Inch -12) (Inch -4)) = (Inch 0).\n

\nNote that in case (i) above, if the absolute value of SCALAR is any value lessThan the absolute value of BASE, SCALAR-MOD-BASE is equal to SCALAR. In all cases, if SCALAR numericallyEquals BASE, SCALAR-MOD-BASE is the comparable null-value. In all cases, the numeric sign of the returned value SCALAR-MOD-BASE agrees with that of BASE (unless the returned value is null). Also note that (ModuloFn SCALAR BASE) is undefined if SCALAR and BASE are not numericallyComparable (q.v.), or if BASE is null. \n

\nIn practice, BASE will usually be a positive integral value, and both SCALAR and the returned value will often be integral as well (see ScalarIntegralValue). Note that if SCALAR and BASE are given in different (but comparable) UnitOfMeasures (e.g. Meter and (Centi Meter)), the result returned by Cyc will be given in the same units as BASE."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tKnowledgeBase,"A specialization of Database-AbstractContent. Each instance of KnowledgeBase is a database (considered as an abstract repository of information rather than a physical storage device) containing knowledge about at least part of the world. A notable specialization of KnowledgeBase is CycKB, the collection of all Cyc knowledge bases."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(istAsserted,"A MicrotheoryDesignatingPredicate that is used to relate CycL sentences to microtheories in which they are explicitly asserted. (ist-Asserted MT SENT) states that there is a CycLAssertion for SENT in the Microtheory MT. This predicate is therefore a more specialized form of ist (q.v.) with the additional requirement that there be an actual assertion for SENT in MT.\n

\nNote that the above is also more precise than (ist MT (call_u_no_bc SENT)), which states that there is an assertion for SENT in some microtheory visible from (see genlMt) MT."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa5_4,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa5-4 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to RELN, a necessary condition for semantic well-formedness is that the fourth argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 ARG3 ARG4 INST ... ARGN) is semantically well-formed only if ARG4 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa5_3,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa5-3 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to RELN, a necessary condition for semantic well-formedness is that the third argument must be an instance of DEPENDENT-ARG-COL. That is, if ARG-INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 ARG3 ARG4 INST ... ARGN) is semantically well-formed only if ARG3 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa5_2,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa5-2 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to RELN, a necessary condition for semantic well-formedness is that the second argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 ARG3 ARG4 INST ... ARGN) is semantically well-formed only if ARG2 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa5_1,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa5-1 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the fifth argument to RELN, a necessary condition for semantic well-formedness is that the first argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 ARG3 ARG4 INST ... ARGN) is semantically well-formed only if ARG1 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa4_5,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa4-5 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the fourth argument to RELN, \na necessary condition for semantic well-formedness is that the fifth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 ARG2 ARG3 INST ARG5 ... ARGN) is semantically \nwell-formed only if ARG5 is an instance of DEPENDENT-ARG-COL. For an explanation \nof semantic well-formedness, see CycLExpression-Assertible and its direct \nspecializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa4_3,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa4-3 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the fourth argument to RELN, \na necessary condition for semantic well-formedness is that the third argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 ARG2 ARG3 INST ... ARGN) is semantically well-formed only \nif ARG3 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa4_2,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa4-2 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the fourth argument to RELN, a necessary condition for semantic well-formedness is that the second argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 ARG3 INST ... ARGN) is semantically well-formed only if ARG2 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa4_1,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa4-1 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the fourth argument to RELN, \na necessary condition for semantic well-formedness is that the first argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 ARG2 ARG3 INST ... ARGN) is semantically well-formed only \nif ARG1 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa3_5,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa3-5 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the third argument to RELN, \na necessary condition for semantic well-formedness is that the fifth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 ARG2 INST ARG4 ARG5 ... ARGN) is semantically \nwell-formed only if ARG5 is an instance of DEPENDENT-ARG-COL. For an explanation \nof semantic well-formedness, see CycLExpression-Assertible and its direct \nspecializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa3_4,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa3-4 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the third argument to RELN, \na necessary condition for semantic well-formedness is that the fourth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 ARG2 INST ARG4 ... ARGN) is semantically well-formed only \nif ARG4 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa3_2,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa3-2 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to RELN, a necessary condition for semantic well-formedness is that the second argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 INST ... ARGN) is semantically well-formed only if ARG2 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa3_1,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa3-1 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the third argument to RELN, a necessary condition for semantic well-formedness is that the first argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 ARG2 INST ... ARGN) is semantically well-formed only if ARG1 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa2_5,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa2-5 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the second argument to RELN, \na necessary condition for semantic well-formedness is that the fifth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 INST ARG3 ARG4 ARG5 ... ARGN) is semantically \nwell-formed only if ARG5 is an instance of DEPENDENT-ARG-COL. For an explanation \nof semantic well-formedness, see CycLExpression-Assertible and its direct \nspecializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa2_4,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa2-4 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the second argument to RELN, \na necessary condition for semantic well-formedness is that the fourth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 INST ARG3 ARG4 ... ARGN) is semantically well-formed only \nif ARG4 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa2_3,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa2-3 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the second argument to RELN, \na necessary condition for semantic well-formedness is that the third argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN ARG1 INST ARG3 ... ARGN) is semantically well-formed only \nif ARG3 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa2_1,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa2-1 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the second argument to RELN, a necessary condition for semantic well-formedness is that the first argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN ARG1 INST ... ARGN) is semantically well-formed only if ARG1 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa1_5,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa1-5 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the first argument to RELN, \na necessary condition for semantic well-formedness is that the fifth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN INST ARG2 ARG3 ARG4 ARG5 ... ARGN) is semantically \nwell-formed only if ARG5 is an instance of DEPENDENT-ARG-COL. For an explanation \nof semantic well-formedness, see CycLExpression-Assertible and its direct \nspecializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa1_4,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa1-4 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the first argument to RELN, \na necessary condition for semantic well-formedness is that the fourth argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN INST ARG2 ARG3 ARG4 ... ARGN) is semantically well-formed only \nif ARG4 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa1_3,"A ternary instance of InterArgIsaPredicate (q.v.). \n(interArgIsa1-3 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, \nwhen an instance of INDEPENDENT-ARG-COL appears as the first argument to RELN, \na necessary condition for semantic well-formedness is that the third argument \nmust be an instance of DEPENDENT-ARG-COL. That is, if INST is\nan instance of INDEPENDENT-ARG-COL, then \n(RELN INST ARG2 ARG3 ... ARGN) is semantically well-formed only \nif ARG3 is an instance of DEPENDENT-ARG-COL. For an explanation of semantic \nwell-formedness, see CycLExpression-Assertible and its direct specializations."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgIsa1_2,"A ternary instance of InterArgIsaPredicate (q.v.). (interArgIsa1-2 RELN INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when an instance of INDEPENDENT-ARG-COL appears as the first argument to RELN, a necessary condition for semantic well-formedness is that the second argument must be an instance of DEPENDENT-ARG-COL. That is, if INST is an instance of INDEPENDENT-ARG-COL, then (RELN INST ARG2 ... ARGN) is semantically well-formed only if ARG2 is an instance of DEPENDENT-ARG-COL.\n

\nFor example, (interArgIsa1-2 performedBy PurposefulAction IntelligentAgent) means that, if ACT is a purposeful action, then (performedBy ACT AGENT) is semantically well-formed only if AGENT is an intelligent agent. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its direct specializations. See interArgIsa for a similar but more general predicate that is quintary, allowing the user to specify the positions of the independent and dependent arguments.\n

\nUse interArgCondIsa1-2 to conclude that arg2 is an instance of DEPENDENT-ARG-COL instead of having that as a constraint."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(interArgFormat1_2,"An instance of InterArgFormatPredicate (q.v.).\n(interArgFormat1-2 PRED COL FORMAT) means that FORMAT is a Format (q.v.)\nrequirement for the second argument-place of PRED when PRED's first argument\nis an instance of COL. That is, with respect to a sentence of the form \n(PRED ARG1 ARG2 ... ARGN) in which ARG1 is an instance of COL, PRED's arg2\nposition (i.e. the position occupied by the metavariable `ARG2' in the \npreceding sentence-form) is subject to FORMAT. See Format and its instances \nfor further explanation."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftInferenceSupportedTerm,"The collection of all CycLTerms that are supported in some way by the CycInferenceEngine. This support may be provided by, for example, a CycHLModule or an evaluationDefn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtInferenceSupportedPredicate,"The collection of all Predicates that are supported in some way by the CycInferenceEngine. This support may be provided by, for example, a CycHLModule or an evaluationDefn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtInferenceSupportedFunction,"The collection of all Function-Denotationals that are supported in some way by the CycInferenceEngine. This support may be provided by, for example, an evaluationDefn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ttInferenceSupportedCollection,"The collection of all CycL terms that denote collections, where these terms are supported in some way by the CycInferenceEngine. If a term T denoting the collection COL is an InferenceSupportedCollection, this means that the inference engine treats instances of COL specially."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtIndeterminateTermDenotingFunction,"IndeterminateTermDenotingFunction is the collection of all functions that denote indeterminate terms. See also IndeterminateTerm, SkolemTerm, and SkolemFunction."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(xtHLExternalIDString,"HLExternalIDString is the collection of all SubLStrings\nwhich represent valid external ID strings for CycLExpressions.\nMembership in this collection is determined for given strings by\nevaluation of the underlying SubL code which implements the object to\nID mapping."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(genlsSpecdenotesgenlinstances,"An instance of TaxonomicSlotForCollections (q.v.) and a specialization of generalizations. genls-SpecDenotesGenlInstances relates a collection (see Collection) to those collections which denote instances of it. More precisely, (genls-SpecDenotesGenlInstances SUBCOL SUPERCOL) means that SUPERCOL is a quoted supercollection of SUBCOL: anything that is quoted instance of (see quotedIsa) SUBCOL is an instance (see isa) of SUPERCOL. For example, (genls-SpecDenotesGenlInstances List-Extensional List) holds."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(genlsGenldenotesspecinstances,"A instance of TaxonomicSlotForCollections (q.v.) and a specialization of generalizations. genls-GenlDenotesSpecInstances relates a given SubLExpressionType collection (see Collection) to those collections whose instances it denotes. More precisely, (genls-GenlDenotesSpecInstances SUBCOL SUPERCOL) means that SUBCOL is a quoted subcollection of SUPERCOL: anything that is an instance of (see quotedIsa) SUBCOL is a quoted instance (see isa) of SUPERCOL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vFriday,"A collection of CalendarDays and an \ninstance of DayOfWeekType. Friday is the collection of all \n(and only) fridays."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vForwardAssertionDirection,"An instance of CycLAssertionDirection (q.v.). A CycL assertion that\nhas the Forward-AssertionDirection can be used in inferences carried \nout at the time the assertion is added to the Knowlege Base as well as \nthose carried out at when a query is asked. This is the default direction \nfor ground atomic assertions (see CycLClosedAtomicSentence). Contrast \nwith Backward-AssertionDirection and Code-AssertionDirection. Also \nsee assertionDirection."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tSetOfFormulaArgSetFn,"(FormulaArgSetFn RELATION-EXPRESSION) denotes\na set of the arguments of the given CycLFormula RELATION-EXPRESSION. For example, (FormulaArgSetFn (genls Dog Animal)) denotes (TheSet Dog Animal). See also FormulaArgFn and FormulaArityFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vFormulaArgListFn,"(FormulaArgListFn RELATION-EXPRESSION) denotes a list of the arguments in RELATION-EXPRESSION. For example, (FormulaArgListFn (genls Dog Animal)) denotes (TheList Dog Animal). See also FormulaArgFn and FormulaArityFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uFOLTermFn,"(FOL-TermFn TERM) denotes a first-order constant symbol\nbased on the CycL term TERM. For example, (FOL-TermFn Dog)\ndenotes a first-order term based on the collection Dog,\n(FOL-TermFn 212) denotes a first-order term based on the integer\n212, and (FOL-TermFn isa) denotes a first-order term based on the\npredicate isa. See also (FOL-PredicateFn isa 2) for the\nfirst-order binary predicate based on isa."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(iFOLPredicateFn,"(FOL-PredicateFn TERM ARITY) denotes a predicate that has\narity ARITY in the first-order projection of CycL based on the CycL\nterm TERM, which must be either a predicate or a collection. For\nexample, (FOL-PredicateFn eventOccursAt 2) denotes the binary\nfirst-order predicate associated with eventOccursAt,\n(FOL-PredicateFn different 2) denotes the first-order binary\nversion of the predicate different, and (FOL-PredicateFn Date 1)\ndenotes the unary first-order predicate associated with Date"),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(iFOLFunctionFn,"(FOL-FunctionFn FUNC ARITY) denotes a function that has\narity ARITY in the first-order projection of CycL based on the CycL\nfunction FUNC. For example, (FOL-FunctionFn YearFn 1) denotes the\nunary first-order function associated with YearFn, and\n(FOL-FunctionFn PlusFn 2) denotes the first-order binary function\nassociated with PlusFn"),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vExpFn,"A unary EvaluatableFunction that is the CycL version of the exponential operator. It takes instances of ComplexNumber and returns instances of ComplexNumber. (ExpFn NUM) is e^NUM, i.e. e raised to the power of NUM (where e is E-LogarithmBase). When NUM is a RealNumber, (ExpFn NUM) is necessarily a PositiveNumber. In particular, (ExpFn 1) is e. The inverse of this function (cf. inverseQuantFunctions-Nonsymmetric\n) is LogFn. Note that although the arg constraint for ExpFn is ComplexNumber, its evaluationDefn only evaluates to a value when NUM is a RealNumber. See also ExponentFn, a binary function which returns the result of raising a specified number to a specified exponent."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uExpandSubLFn,"(ExpandSubLFn PARAMETERS SUBL-TEMPLATE) denotes the SubL expression resulting from expanding the SubL template SUBL-TEMPLATE once all PARAMETERS are known. For example, (ExpandSubLFn (?X) (+ 1 ?X)) will denote the SubL expression (+ 1 2) when the parameter ?X is bound to 2. See also EvaluateSubLFn, trueSubL and performSubL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtExceptionPredicate,"A collection of mathematical objects, which are the LogicalConnectives used to express exceptions to rules. Elements include exceptWhen and exceptFor."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(uEvaluateSubLFn,"(EvaluateSubLFn SUBL) denotes the SubL term resulting from the invocation of the SubL EVAL facility on the expression SUBL. For example, (EvaluateSubLFn (ExpandSubLFn () (+ 1 2))) evaluates to 3. See ExpandSubLFn for a way to denote SubL within CycL. See also trueSubL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtEvaluatablePredicate,"A specialization of both EvaluatableRelation and Predicate (qq.v.). Each instance of EvaluatablePredicate is a predicate associated (via evaluationDefn) with a piece of HL (\"heuristic level\") code that computes the resulting truth-value when the predicate is applied to legal \narguments. These truth-values can, of course, be computed only when all of the predicate's argument positions are bound: thus Cyc inference will not generate viable inference tactics for non-fully-bound literals with evaluatable predicates in the arg 0 position. As one might expect, most evaluatable predicates are mathematical or syntactic in nature; for numbers, sets, lists, and strings are the sorts of things that are related in various ways that can be calculated \nalgorithmically. Examples include greaterThan and substring. Thus the sentence `(greaterThan 3 1)' evaluates to (and so if used to ask a query will return the answer) `True'."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(xDateEncodeStringFn,"(DateEncodeStringFn TEMPLATE DATE) returns a string encoding of DATE (an instance of Date) in the format described by the TEMPLATE string. For example, (DateEncodeStringFn 'MM/DD/YYYY' (DayFn 20 (MonthFn July (YearFn 1969)))) would return '07/20/1969'. See also DateDecodeStringFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(iTimeOf_DateDecodeStringFn,"(DateDecodeStringFn TEMPLATE DATE-STRING) returns a Date which is the result of decoding DATE-STRING by the format described by the TEMPLATE string. For example, (DateDecodeStringFn 'MM/DD/YYYY' '07/20/1969') would return (DayFn 20 (MonthFn July (YearFn 1969))). See also DateEncodeStringFn."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tCycTransformationProof,"The nearestGenls of CycProof each of whose instances uses a CycLRuleAssertion to prove a query."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftTruthValueSentence,"A collection of CycL sentences containing only the CycL sentences True and False, both of which are sentential constants."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftSentenceAssertible,"The subcollection of CycLSentences whose arg0 does not contain a free variable although free variables may occupy other argument positions."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftNonAtomicTerm,"The subcollection of denotational CycLNonAtomicTerms which have no free variable in the arg0 position.\nExamples: (JuvenileFn Platypus), (JuvenileFn isa genls), (TheSetOf ?X (colorOfType ?X GreenColor)), (JuvenileFn ?X). Counterexample: (?SOMEFN Gold) ((USDollarFn ?YEAR) 5)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftSentence,"A subcollection of syntactically well-formed sentences of the CycL language. Each instance of CycLFormulaicSentence consists of a CycL expression denoting an instance of TruthFunction (e.g., an instance of Predicate or SententialRelation) followed by one or more CycL terms (see CycLTerm), with the entire sequence enclosed in parentheses. For example, (isa Collection Thing) and (genls ?FOO SpatialThing) are both formulaic CycL sentences. The only two CycL sentences that are not formulaic are True and False. Note that CycLFormulaicSentences need not obey arity constraints (see arity) or other semantic constraints (such as argument type constraints ; see ArgTypePredicate). CycLFormulaicSentences are also called \"logical formulas\", and are to be distinguished from \"denotational formulas\" (which are also known as \"NAT\"s; see CycLNonAtomicTerms). Note that this notion of a formulaic CycL sentence is broader than the notion of \"sentence\" standardly used in formal logic, where a sentence is defined as a _closed_ well-formed formula: formulaic CycL sentences may be _open_ (i.e., contain free variables; see CycLOpenSentence)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vtAssertionDirection,"The collection of possible inference \"directions\" that a CycLAssertion\ncan have. A given CycL assertion's direction (see assertionDirection) \nindicates something about how and when the assertion can be used in inferences\nby the Cyc system. More precisely: Backward-AssertionDirection indicates\nthat the assertion can only be used in inferences carried out when a query\nis asked; Forward-AssertionDirection indicates that the assertion can be used \nin inferences carried out at the time the assertion is added to the Knowledge \nBase as well as those carried out at ask-time; and Code-AssertionDirection\nindicates that the assertion itself cannot be used in either backward \n(ask-time) or forward (assert-time) inferences, but is instead implemented \nin the underlying code of the Cyc system. Each CycL assertion has exactly \none of the above three directions; the default direction is Forward for \nground atomic assertions (see CycLClosedAtomicSentence) and Backward for \nrule assertions. Note that a CycL sentence is given a direction at the time \nof its assertion to the system, and this fact _need_not_ be reflected in \nanother, assertionDirection assertion's being added to the system (as\nthat would of course lead to an infinite regress)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tCycInferenceBindingsDataStructure,"A specialization of CycInferenceDataStructure. Each\ninstance of CycInferenceBindingsDataStructure is a component of one\nor more CycInferenceAnswers, and encodes an assignment of bindings\nto the free variables in the query which yielded that answer\n(i.e., the query which triggered the CycInference of which that\nanswer is a part). If the triggering query is closed, the binding\nlist value is NIL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tCycInferenceAnswerJustification,"A specialization of CycInferenceDataStructure. Each\ninstance of CycInferenceAnswerJustification is a component of one or\nmore CycInferenceAnswers, and, in each case, encodes a complete set\nof supports (cf., CycSupportDatastructure) for that answer's binding\nlist. See also CycInferenceBindingsDataStructure."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(tCycInferenceAnswer,"A specialization of CycInferenceDataStructure. Each\ninstance of CycInferenceAnswer is a complex data structure that is a\ncomponent of one or more CycInferences (specifically, of certain\ninferences whose root problem is proven). A CycInferenceAnswer has\ntwo components: an assigment of bindings to query variables and sets of justifications for those bindings. For information about the components, see the predicates inferenceAnswerBindings and inferenceAnswerJustification."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vtHLTruthValue,"The truth/strength combinations used in the Cyc HL implementation of CycLAssertions and arguments."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(iCollectionRuleTemplateFn,"(CollectionRuleTemplateFn COL) denotes the rule template unique to collection COL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtCollectionDenotingFunction,"The subcollection of Function-Denotational whose instances return instances of Collection. Examples include SwimmingEventFn, GroupFn, and MoleculeFn. For example, (MoleculeFn Oxygen) denotes the collection of all oxygen molecules. See also the collections IndividualDenotingFunction and SetDenotingFunction."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vCodeAssertionDirection,"An instance of CycLAssertionDirection (q.v.). A CycL assertion that\nhas the Code-AssertionDirection cannot itself be used in either \nbackward (ask-time) or forward (assert-time) inferences, but is instead \nimplemented in the underlying code of the Cyc system. Contrast with \nBackward-AssertionDirection and Forward-AssertionDirection. Also \nsee assertionDirection."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ftString,"A specialization of AbstractInformationStructure. Each instance of CharacterString is a string of characters or an abstract sequence of symbols. Note that an instance of CharacterString is not any particular physical, tangible representation, since different encodings may represent the same string of characters. An instance of CharacterString is a list (see the collection List) of characters (instances of Character-Abstract) from some fixed character set. An instance of CharacterString may be any finite length, including zero (the zero-length string is the empty string, which has no characters). Notable specializations of CharacterString include EMailAddress, AreaCode, PhoneNumber, and TelephoneCountryCode. Note that a CharacterString is ordered formally as a List (rather than physically left-to-right or top-to-bottom); thus the 'first' character in the CharacterString for an Arabic word happens to be the rightmost (first pronounced) character, not the leftmost character, due to the letter-order and word-order convention for Arabic writing."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtBinaryRelation,"The collection of all fixed-arity relations of arity 2 (see arity). The most notable specializations of BinaryRelation are BinaryPredicate and BinaryFunction (qq.v.)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(vBackwardAssertionDirection,"An instance of CycLAssertionDirection (q.v.). A CycL assertion that\nhas the Backward-AssertionDirection can only be used in inferences that \nare carried out when a query is asked. This is the default direction for \nrule assertions. Contrast with Forward-AssertionDirection and Code-AssertionDirection. Also see assertionDirection."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(ttAtemporalNecessarilyEssentialCollectionType,"A collection of collections. Each instance COL of AtemporalNecessarilyEssentialCollectionType (ANECT) is a collection satisfying three conditions: (1) COL is disjoint with (see disjointWith) TemporalThing, (2) every instance INST of COL is an instance of COL essentially (i.e. INST is an instance of COL, and could not exist without being an instance of COL), and (3) condition (2) is a necessary truth about COL.\n

\nPositive examples of ANECTs include Collection, Integer, and Relation (each of which is a collection of atemporals and is such that, necessarily, all of its instances are in it essentially). Negative examples include SpatialThing (though arguably it is necessary that all of its instances are essentially instances of it, it is not disjoint with TemporalThing) and UniqueAnatomicalPartType (which, though disjoint with TemporalThing, has instances, such as Heart, that could exist even if they weren't instances of it; e.g. it might have been the case that every creature with a heart had at least two hearts). There are no known examples of Cyc-reified collections satisfying conditions (1) and (2) but not (3), but one can be contrived. Suppose that all of today's winning lottery numbers were primes. Now consider the collection:\n

\n (CollectionUnionFn \n (TheSet PrimeNumber TodaysWinningLotteryNumbers))\n

\nThis collection is clearly disjoint with TemporalThing and, by hypothesis, all of its instances are in it essentially (as each prime number is essentially a prime number). But this last fact is not necessarily true of this collection: the collection might have had instances that belonged to it only contingently (i.e. not essentially), as it might have been the case that one of today's winning lottery numbers was non-prime, and no number is such that it is essentially one of today's winning lottery numbers.\n

\nWhen asserting that something is an instance or specialization of a given instance of ANECT, it is appropriate to do so in the UniversalVocabularyMt (q.v.). Indeed, ANECT was specially defined to facilitate the movement of appropriate assertions to that microtheory.\n

\nCf. PragmaticallyDecontextualizedCollection."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtAssociativeRelation,"The collection of polyadic Relations having the property of associativity. Roughly speaking, a relation is associative if certain different sequences of recursive applications of it lead to the same final result.\n

\nMore precisely: If RELN is binary, it is an instance of AssociativeRelation if and only if (for any appropriate arguments A, B, and C) the corresponding formulas (RELN A (RELN B C)) and (RELN (RELN A B) C) are (extensionally) equivalent: if RELN is a Function-Denotational both formulas have the same denotatum (or both have no denotatum), while if RELN is a Predicate or LogicalConnective both formulas have the same truth value. If RELN has a higher arity than two, the definition is similar, but with the relevant formula schemata appropriately rewritten. If RELN is variable-arity (see VariableArityRelation), it is an AssociativeRelation if and only of it behaves associatively with respect to each of the particular arities it subsumes (its arityMin to arityMax). No unary relation is associative. \n

\nIt follows from the above definition that that each argument-place of an associative relation must admit exactly the same class of arguments (see admittedArgument), and that its results must also be of that same class (so that it can be applied recursively).\n

\nExamples of associative relations include PlusFn, TimesFn, JoinListsFn, SpatialSumFn, or, and and.\n

\nNote that, while many AssociativeRelations are CommutativeRelations (q.v.), this is not always the case. Consider for example ConcatenateStringsFn. Since it is associative, (('c'^'a')^'t') = ('c'^('a'^'t')) = 'cat'. But it is certainly not commutative: 'cat' =/ 'act'."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(assertionUtility_1,"A CycInferenceHeuristicRelevancePredicate. (assertionUtility ASSERTION NUM) states that the CycLAssertion ASSERTION should be heuristically considered of utility NUM to inferences made in the current Microtheory. NUM should be a RealNumber between 1 and -1, with 1 indicating maximum utility, -1 indicating minimum utility, and 0 being agnostic with respect to utility. (assertionUtility ASSERTION 1) is equivalent to (highlyRelevantAssertion ASSERTION). (assertionUtility ASSERTION -1) is equivalent to (irrelevantAssertion ASSERTION). See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtArgSometimesIsaPredicate,"The collection of ArgTypePredicates (q.v.) that specify argument-types\ndirectly (by referencing certain collections) and impose constraints that\nrequire an argument of a predicate being an instance of a SubLExpressionType\ncollection at some time. More precisely, each instance\nof ArgSometimesIsaPredicate PRED takes a Relation RELN as its first argument (or\n\"arg1\"), and has at least one other argument-place (say the Mth) for\nspecifying an argument-type for one of RELN's argument-places (say the\nNth). (The value of N might be fixed or might be given by yet another of PRED's\narguments.) Suppose M=2 and N=1. PRED then takes a SubLExpressionType Collection\nas its second argument, and a closed atomic sentence (or \"GAF\") of the form\n(PRED RELN COL ..) puts a \"sometimes isa\" constraint on RELN's first\nargument-place that is based on COL. If PRED is a \"single-argument\" constraint\npredicate, the GAF entails that a closed formula of the form (RELN ARG1 ..) is\nsemantically well-formed only if ARG1 is an instance of \nSubLExpressionType COL in some time interval\n(including Always-TimeInterval)."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtArgQuotedIsaTernaryPredicate,"A specialization of ArgQuotedIsaPredicate (q.v.). Each instance of ArgQuotedIsaTernaryPredicate. is a ternary predicate used to place an \"quoted isa\" constraint on (and thereby specify an argument-type for) one or more argument-places of a relation. To be more precise, each instance PRED of ArgQuotedIsaTernaryPredicate takes a Relation RELN as its first argument, a NonNegativeInteger N as its second argument, and a SubLExpressionType collection COL as its third argument. PRED places an \"quoted isa\" constraint on RELN's Nth argument-place that is based on COL, so that a ground atomic sentence (GAF) of the form (RELN ARG1..ARGN..) is semantically well-formed only if ARGN is a quoted instance of COL. (Note that if N = 0 then this same constraint is placed on _all_ of RELN's argument-places. An important instance of ArgQuotedIsaTernaryPredicate is argQuotedIsa."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtArgQuotedIsaPredicate,"The collection of ArgTypePredicates (q.v.) that specify argument-types directly (by referencing certain collections) and impose constraints that require a thing's being an instance of a SubLExpressionType collection thus specified. More precisely, each instance of ArgQuotedIsaPredicate PRED takes a Relation RELN as its first argument (or \"arg1\"), and has at least one other argument-place (say the Mth) for specifying an argument-type for one of RELN's argument-places (say the Nth). (The value of N might be fixed or might be given by yet another of PRED's arguments.) Suppose M=2 and N=1. PRED then takes a SubLExpressionType Collection as its second argument, and a closed atomic sentence (or \"GAF\") of the form (PRED RELN COL ..) puts an \"quoted isa\" constraint on RELN's first argument-place that is based on COL. If PRED is a \"single-argument\" constraint predicate, the GAF entails that a closed formula of the form (RELN ARG1 ..) is semantically well-formed only if ARG1 is an instance of (i.e. quotedIsa) SubLExpressionType COL."),iUniversalVocabularyMt,vStrMon). tiny_kb(comment(rtArgQuotedIsaBinaryPredicate,"A specialization of ArgQuotedIsaPredicate . Each instance of ArgQuotedIsaBinaryPredicate takes a Relation RELN as its first argument, and a SubLExpressionType Collection COL as its second argument, and places a constraint based on COL on at least one of the argument-places of RELN. To be more precise, suppose that PRED is an ArgIsaBinaryPredicate that specifies an argument-type for the Nth argument-place of RELN. Then a sentence of the form (PRED RELN COL) entails that a closed formula of the form (RELN ... ARGN ...) is semantically well-formed only if ARGN is an instance (i.e. quotedIsa) of COL."),iUniversalVocabularyMt,vStrMon). tiny_kb(relationAll(call_u_no_bc,ftAssertion),iUniversalVocabularyMt,vStrMon). tiny_kb(relationAll(decontextualizedCollection,ttAtemporalNecessarilyEssentialCollectionType),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(istAsserted(MT,FORMULA),ist(MT,call_u_no_bc(FORMULA))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(knownAntecedentRule(ASSERTION),highlyRelevantAssertion(ASSERTION)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(termOfUnit(UNITPRODUCTFN,cycUnitProductFn(PERFN,UNIT2)),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT2))),equals(UNIT1,UNITPRODUCTFN)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(termOfUnit(PERFN,cycPerFn(UNITPRODUCTFN,UNIT2)),termOfUnit(UNITPRODUCTFN,cycUnitProductFn(UNIT1,UNIT2))),equals(PERFN,UNIT1)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,6,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,6,COL]],[[arg6SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,6,COL],[arg6SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,5,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,5,COL]],[[arg5SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,5,COL],[arg5SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,4,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,4,COL]],[[arg4SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,4,COL],[arg4SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,3,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,3,COL]],[[arg3SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,3,COL],[arg3SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,2,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,2,COL]],[[arg2SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,2,COL],[arg2SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(call_u_no_bc(argSometimesIsa(RELN,1,COL)),meetsPragmaticRequirement(vTheListFn(RELN,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[argSometimesIsa,RELN,1,COL]],[[arg1SometimesIsa,RELN,COL]]],iUniversalVocabularyMt,s("?RELN","?COL"),[implies,[argSometimesIsa,RELN,1,COL],[arg1SometimesIsa,RELN,COL]]))),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(admittedAllArgument(COL,NUM,RELN),relationAllInstance(iKappaFn('?X'(Y),admittedArgument(X,NUM,Y)),COL,RELN)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(ttUnitOfMeasure(UNITPRODUCTFN),ttUnitOfMeasure(PERFN),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT2)),termOfUnit(UNITPRODUCTFN,cycUnitProductFn(PERFN,UNIT2))),equals(UNIT1,UNITPRODUCTFN)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(ftPositiveInteger(M),ftPositiveInteger(N),different(M,N,1)),interArgDifferent(commutativeInArgs,M,N)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(isa(INST,COL),admittedAllArgument(COL,NUM,RELN)),admittedArgument(INST,NUM,RELN)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(elInverse(PRED,INVERSE),argIsa(PRED,2,COL)),argIsa(INVERSE,1,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(elInverse(PRED,INVERSE),argGenl(PRED,2,COL)),argGenl(INVERSE,1,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(elInverse(PRED,INVERSE),argIsa(PRED,1,COL)),argIsa(INVERSE,2,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(elInverse(PRED,INVERSE),argGenl(PRED,1,COL)),argGenl(INVERSE,2,COL)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(decontextualizedPredicate(PRED),predicateConventionMt(PRED,MT)),genlMt(iBaseKB,MT)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(decontextualizedCollection(COL),collectionConventionMt(COL,MT)),genlMt(iBaseKB,MT)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(argFormat(GENLPRED,4,vSingleEntry),different(GENLPRED,SPECPRED),genlPreds(SPECPRED,GENLPRED)),argFormat(SPECPRED,4,vSingleEntry)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(argFormat(GENLPRED,3,vSingleEntry),different(GENLPRED,SPECPRED),genlPreds(SPECPRED,GENLPRED)),argFormat(SPECPRED,3,vSingleEntry)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(argFormat(GENLPRED,2,vSingleEntry),different(GENLPRED,SPECPRED),genlPreds(SPECPRED,GENLPRED)),argFormat(SPECPRED,2,vSingleEntry)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(trueSentence(all(INST,implies(isa(INST,COL),admittedArgument(INST,NUM,RELN)))),admittedAllArgument(COL,NUM,RELN)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(trueSentence(SENT),sentenceTruth(SENT,vTrue)),iUniversalVocabularyMt,vStrMon). tiny_kb(implies(and(evaluate(QUOTIENTFN,vQuotientFn('NART'([UNIT1|ARGS]),'NART'([UNIT2,1]))),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT2))),equals(QUOTIENTFN,'NART'([PERFN|ARGS]))),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainRequired(sentenceTruth),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(unknownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(termOfUnit),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(termExternalIDString),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(sentenceImplies),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(sentenceEquiv),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(mtVisible),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(knownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(integerBetween),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(indexicalReferent),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(extentCardinality),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(differentSymbols),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(consistent),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(conceptuallyRelated),iUniversalVocabularyMt,vStrMon). tiny_kb(backchainForbidden(equalStringsCaseinsensitive),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertibleMt(iLogicalTruthMt),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertibleMt(iInferencePSC),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertibleMt(iEverythingPSC),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertibleCollection(ftTruthValueSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertible(termExternalIDString),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertible(sentenceTruth),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertible(querySentence),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertible(forwardNonTriggerLiteral),iUniversalVocabularyMt,vStrMon). tiny_kb(notAssertible(constantGUID),iUniversalVocabularyMt,vStrMon). tiny_kb(minimizeExtent(genlMt),iUniversalVocabularyMt,vStrMon). tiny_kb(completelyDecidableCollection(tMicrotheory),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(termChosen),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(quotedArgument),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(pragmaticRequirement),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(performSubL),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(operatorFormulas),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(natFunction),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(natArgumentsEqual),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(natArgument),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(myCreationPurpose),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(formulaArity),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(exactlyAssertedEL_next),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(evaluate),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(equalSymbols),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(definingMt),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycTransformationProofRule),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycTransformationProofBindings),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreTerms),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreProofCount),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreProblems),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreProblemCount),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreLinkCount),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemStoreInferenceCount),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemQueryTerms),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemQuerySentence),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(cycProblemProvabilityStatus),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(constantName),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(constantID),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(constantGUID),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(comment),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(collectionIsaBackchainRequired),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(collectionGenlsBackchainRequired),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(collectionBackchainEncouraged),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(backchainRequired),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(backchainForbiddenWhenUnboundInArg),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(backchainForbidden),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(assertionDirection),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(assertedTermSentences),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(call_u_no_bc),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(assertedPredicateArg),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(admittedSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(admittedArgument),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentEnumerable(istAsserted),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(unknownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(termOfUnit),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(sentenceImplies),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(sentenceEquiv),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(mtVisible),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(knownSentence),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(integerBetween),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(indexicalReferent),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(differentSymbols),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(consistent),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(conceptuallyRelated),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentDecidable(equalStringsCaseinsensitive),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentAsserted(resultIsaArgIsa),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentAsserted(instanceElementType),iUniversalVocabularyMt,vStrMon). tiny_kb(completeExtentAsserted(hypotheticalTerm),iUniversalVocabularyMt,vStrMon). tiny_kb(not(and(isa(INST_1,COL1),isa(INST_2A,COL2),different(INST_2A,INST_2B),isa(INST_2B,COL2),t(PRED,INST_1,INST_2B),t(PRED,INST_1,INST_2A),relationAllExistsMax(PRED,COL1,COL2,1))),iUniversalVocabularyMt,vStrMon). tiny_kb(argQuotedIsa(xor,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xor,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(unknownSentence,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueSubL,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueRule,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exists,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exists,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistExactly,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistExactly,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtMost,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtMost,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtLeast,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtLeast,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termOfUnit,2,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termOfUnit,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termExternalIDString,1,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termDependsOn,2,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termDependsOn,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sharedNotes,2,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sharedNotes,1,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceImplies,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceImplies,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceEquiv,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceEquiv,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(salientAssertions,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(salientAssertions,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ruleAfterRemoving,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ruleAfterAdding,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(rewriteOf,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(rewriteOf,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(relationExpansion,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRuleProperties,2,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRule,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRule,1,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquiv,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquiv,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquals,2,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquals,1,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulationPrecondition,3,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulationDirectionInMode,3,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnSufficient,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnNecessary,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnIff,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(querySentence,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(prettyString,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticRequirement,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticRequirement,1,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pointQuantValue,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(performSubL,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(or,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(operatorFormulas,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(operatorFormulas,1,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(oldConstantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(oldConstantName,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(not,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natFunction,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgumentsEqual,2,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgumentsEqual,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgument,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreator,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreationSecond,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreationPurpose,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(minimize,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(knownSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(knownAntecedentRule,1,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ist,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantPredAssertion,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantAssertion,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(indexicalReferent,1,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(implies,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(implies,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hypotheticalTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(holdsIn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hlPrototypicalInstance,1,ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hlPrototypicalInstance,1,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantPredAssertion,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantAssertion,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genMassNoun,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genlRules,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genlRules,1,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genKeyword,2,ftKeyword),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genKeyword,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genFormat,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(forwardNonTriggerLiteral,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(formulaArity,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(all,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(all,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(expansionDefn,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(expansion,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptWhen,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptWhen,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptFor,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptFor,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(except,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exampleAssertions,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exampleAssertions,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exactlyAssertedEL_next,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(evaluationDefn,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(equiv,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(equiv,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ephemeralTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnSufficient,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnNecessary,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnIff,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(definingMt,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycTransformationProofRule,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemStoreTerms,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemQueryTerms,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemQuerySentence,2,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constraint,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantName,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantID,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantGUID,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(consistent,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(collectionExpansion,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionUtility,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionDirection,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertedTermSentences,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertedTermSentences,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(call_u_no_bc,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(arity,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argSometimesIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argAndRestIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(and,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(afterRemoving,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(afterAdding,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(admittedSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(admittedNAT,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(abnormal,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xUncanonicalizerAssertionFn,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xTLVariableFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xTLAssertionFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfTheSetOfFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfTheSetOfFn,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tColOfTheCollectionOfFn,2,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tColOfTheCollectionOfFn,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uSubLQuoteFn,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,3,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,3,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xQuasiQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(prettyStringCanonical,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iKappaFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iKappaFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(istAsserted,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(vFormulaArityFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfFormulaArgSetFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(vFormulaArgListFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uFormulaArgFn,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uExpandSubLFn,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uExpandSubLFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uEvaluateSubLFn,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xEscapeQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionUtility_1,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,3,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,3,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(trueSubL,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(trueRule,1,tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,2,rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,2,rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistExactly,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistAtMost,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistAtLeast,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termOfUnit,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termOfUnit,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termExternalIDString,2,xtHLExternalIDString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termExternalIDString,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termDependsOn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termDependsOn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termChosen,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,3,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substring,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substring,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(subsetOf,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(subsetOf,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(skolemizeForward,1,rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(skolem,1,rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(singleEntryFormatInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(singleEntryFormatInArgs,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(siblingDisjointExceptions,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(siblingDisjointExceptions,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sharedNotes,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sharedNotes,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceTruth,2,vtTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceDesignationArgnum,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceDesignationArgnum,1,rtMicrotheoryDesignatingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(scopingArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(scopingArg,1,rtScopingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(salientAssertions,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleTemplateDirection,2,vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleTemplateDirection,1,tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterRemoving,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterRemoving,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterAdding,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterAdding,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(rewriteOf,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(rewriteOf,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultQuotedIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArgIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArgIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArg,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenlArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenlArg,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg3Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg3Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg2Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg2Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg1Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg1Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExpansion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAll,1,rtUnaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRuleProperties,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRule,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRule,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorEquals,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorEquals,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationDirectionInMode,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationDirectionInMode,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,3,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnSufficient,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnSufficient,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnNecessary,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnNecessary,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnIff,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnIff,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedArgument,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantitySubsumes,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantitySubsumes,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantityIntersects,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantityIntersects,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyString,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyString,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(preservesGenlsInArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(preservesGenlsInArg,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(predicateConventionMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(predicateConventionMt,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,1,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(performSubL,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(overlappingExternalConcept,3,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(overlappingExternalConcept,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(openEntryFormatInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(openEntryFormatInArgs,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(opaqueArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(opaqueArgument,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(omitArgIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(omitArgIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(oldConstantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(oldConstantName,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(numericallyEquals,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(numericallyEquals,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,4,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,3,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,4,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,3,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertibleMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertibleCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertible,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,3,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natFunction,2,rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natFunction,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgumentsEqual,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgumentsEqual,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreator,2,mobCyclist),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreator,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationTime,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationTime,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationSecond,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationSecond,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationPurpose,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationPurpose,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,3,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtVisible,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minQuantValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minimizeExtent,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(microtheoryDesignationArgnum,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(microtheoryDesignationArgnum,1,rtMicrotheoryDesignatingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(means,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(means,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(maxQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(maxQuantValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ist,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(isa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantPredAssertion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,5,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,5,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,5,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,3,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,1,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(instanceElementType,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(instanceElementType,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(indexicalReferent,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(indexicalReferent,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,1,rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,1,rtArgConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hypotheticalTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(holdsIn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hlPrototypicalInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hlPrototypicalInstance,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantPredAssertion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThanOrEqualTo,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThanOrEqualTo,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThan,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThan,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genMassNoun,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,2,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,1,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genKeyword,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,3,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(formulaArity,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(formulaArity,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(followingValue,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(followingValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fanOutArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fanOutArg,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extentCardinality,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extentCardinality,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,4,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expresses,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expresses,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansionDefn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansionDefn,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansion,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansion,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exceptMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exceptFor,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exampleAssertions,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationResultQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationResultQuotedIsa,1,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationDefn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationDefn,1,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluateImmediately,1,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluateAtEL,1,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluate,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluate,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalSymbols,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalSymbols,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equals,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equals,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ephemeralTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,2,iELRelationOneWay),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elementOf,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elementOf,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(disjointWith,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(disjointWith,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(different,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(denotes,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(denotes,1,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnSufficient,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnSufficient,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnNecessary,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnNecessary,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnIff,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnIff,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(definingMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(definingMt,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulatorModePrecedence,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,3,rtReformulatorDirectivePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(decontextualizedPredicate,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(decontextualizedCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofRule,1,tCycTransformationProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofBindings,2,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofBindings,1,tCycTransformationProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,1,tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,1,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreTerms,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreTerms,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofs,2,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofs,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblems,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblems,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblemCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblemCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinks,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinkCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinkCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferences,2,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferences,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferenceCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferenceCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreID,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreID,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQueryTerms,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQueryTerms,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQuerySentence,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemProvabilityStatus,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemProvabilityStatus,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,1,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemDependentLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemDependentLinks,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemArgumentLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemArgumentLinks,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceRelevantProblems,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceRelevantProblems,1,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceAnswerLink,2,tCycProblemLinkAnswerLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceAnswerLink,1,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constrainsArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constrainsArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantName,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantID,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantID,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantGUID,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantGUID,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(conceptuallyRelated,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(conceptuallyRelated,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completelyEnumerableCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completelyDecidableCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableViaBackchain,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerable,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidable,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAsserted,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgsAndRest,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgsAndRest,1,rtPartiallyCommutativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(comment,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(comment,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionIsaBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionIsaBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionGenlsBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionGenlsBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionExpansion,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionExpansion,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionConventionMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionConventionMt,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionCompletelyEnumerableViaBackchain,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(coExtensional,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(coExtensional,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,3,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,3,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,2,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainRequired,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbiddenWhenUnboundInArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbiddenWhenUnboundInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbidden,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionUtility,2,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionDirection,2,vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedTermSentences,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMin,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMin,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMax,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMax,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,1,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsQuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsGenl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsGenl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,3,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,3,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterRemoving,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterRemoving,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterAdding,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterAdding,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedNAT,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,3,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,3,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(abnormal,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vUnityFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycUnitProductFn,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycUnitProductFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xUncanonicalizerAssertionFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLVariableFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLVariableFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLReifiedNatFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLAssertionFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vTimesFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(tSetOfTheSetFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vTheListFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substringCaseinsensitive,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substringCaseinsensitive,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fSkolemFuncNFn,4,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundUpFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundDownFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundClosestFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuotientFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuotientFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xQuasiQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuantityConversionFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuantityConversionFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyStringCanonical,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyStringCanonical,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,2,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycPerFn,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycPerFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPercentFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtUnionFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeWithGranularityDimFn,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeWithGranularityDimFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeDimFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtSpaceFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vModuloFn,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vModuloFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinRangeFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinimumFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinimumFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iMeaningInSystemFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iMeaningInSystemFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaxRangeFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaximumFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaximumFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vLogFn,1,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vLogFn,1,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(istAsserted,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vIntervalMinFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vIntervalMaxFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsSpecdenotesgenlinstances,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsSpecdenotesgenlinstances,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsGenldenotesspecinstances,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsGenldenotesspecinstances,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFunctionToArgFn,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFunctionToArgFn,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vFormulaArityFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(tSetOfFormulaArgSetFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vFormulaArgListFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFormulaArgFn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFormulaArgFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFOLTermFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLPredicateFn,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLPredicateFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLFunctionFn,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLFunctionFn,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vExpFn,1,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uEvaluateSubLFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xEscapeQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalStringsCaseinsensitive,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalStringsCaseinsensitive,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vDifferenceFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vDifferenceFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xDateEncodeStringFn,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xDateEncodeStringFn,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iTimeOf_DateDecodeStringFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iTimeOf_DateDecodeStringFn,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycTacticFn,2,tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycTacticFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProofFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProofFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemStoreFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemLinkFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemLinkFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCycInferenceFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCycInferenceFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCollectionRuleTemplateFn,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAverageFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAverageFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionUtility_1,2,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAbsoluteValueFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(genlPreds,2,rtFixedArityRelation,1,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(negationPreds,1,rtUnaryPredicate,2,rtUnaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(negationPreds,1,rtTernaryPredicate,2,rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(negationPreds,1,rtQuintaryPredicate,2,rtQuintaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(negationPreds,1,rtQuaternaryPredicate,2,rtQuaternaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(negationPreds,1,rtBinaryPredicate,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(interArgIsa(arity,1,tPred,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(relationAllExists(cycProblemStoreID,tProblemStore,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(relationAllExists(cycProblemStoreInferences,tProblemStore,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(relationAllInstance(resultIsa,rtCollectionDenotingFunction,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa1_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa1_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa1_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa1_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa2_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa2_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa2_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa2_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa3_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa3_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa3_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa3_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa4_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa4_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa4_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa4_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa5_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa5_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa5_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(interArgIsa5_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(defnSufficient,genls,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationAllExistsMin,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationAllExistsMin,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsAll,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsAll,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsCountAll,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsInstance,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsInstance,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsMinAll,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationExistsMinAll,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationInstanceAll,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationInstanceExists,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationInstanceExists,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationInstanceMember,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(relationMemberInstance,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(requiredArg1Pred,genlPreds,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(requiredArg2Pred,genlPreds,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArg(subsetOf,subsetOf,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_2,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_2,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_3,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_3,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_4,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_4,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_5,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_5,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa1_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_1,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_1,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_3,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_3,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_4,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_4,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_5,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_5,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa2_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_1,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_1,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_2,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_2,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_4,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_4,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_5,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_5,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa3_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_1,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_1,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_2,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_2,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_3,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_3,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_5,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_5,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa4_5,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_1,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_1,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_1,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_2,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_2,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_2,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_3,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_3,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_3,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_4,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_4,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(interArgIsa5_4,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(defnNecessary,genls,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(disjointWith,genls,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(disjointWith,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExists,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExistsCount,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExistsMax,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExistsMax,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExistsMax,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllExistsMin,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationAllInstance,quantitySubsumes,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationExistsAll,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationExistsMaxAll,genlPreds,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationExistsMaxAll,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationExistsMaxAll,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationExistsMinAll,genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(relationInstanceAll,genls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(requiredArg1Pred,genls,1),iUniversalVocabularyMt,vStrDef). tiny_kb(transitiveViaArgInverse(requiredArg2Pred,genls,1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(xor),iUniversalVocabularyMt,vStrDef). tiny_kb(iELRelationOneWay(xor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(xor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(xor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(xor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(unknownSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(unitMultiplicationFactor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(trueSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(trueSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(trueSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(trueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(trueRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(transitiveViaArgInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(transitiveViaArgInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(transitiveViaArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(transitiveViaArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtExistentialQuantifier(exists),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(exists),iUniversalVocabularyMt,vStrDef). tiny_kb(vExistentialQuantifierBounded(thereExistExactly),iUniversalVocabularyMt,vStrDef). tiny_kb(vExistentialQuantifierBounded(thereExistAtMost),iUniversalVocabularyMt,vStrDef). tiny_kb(vExistentialQuantifierBounded(thereExistAtLeast),iUniversalVocabularyMt,vStrDef). tiny_kb(tReformulatorIrrelevantFORT(termOfUnit),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(termOfUnit),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(termOfUnit),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(termExternalIDString),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(termDependsOn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(termChosen),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(termChosen),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(synonymousExternalConcept),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(substring),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(substring),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(substring),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiSymmetricBinaryPredicate(substring),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(subsetOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(subsetOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(skolemizeForward),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(skolem),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFSupportedPredicate(singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(siblingDisjointExceptions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(siblingDisjointExceptions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDocumentationPredicate(sharedNotes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDistributingMetaKnowledgePredicate(sharedNotes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(sharedNotes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(sentenceTruth),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(sentenceImplies),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(sentenceImplies),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(sentenceEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(sentenceEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(sentenceEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(sentenceEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(sentenceDesignationArgnum),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(scopingArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDocumentationPredicate(salientAssertions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDistributingMetaKnowledgePredicate(salientAssertions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(salientAssertions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(ruleTemplateDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(ruleTemplateDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(ruleAfterRemoving),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(ruleAfterAdding),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(rewriteOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(rewriteOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(rewriteOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(rewriteOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulationRulePredicate(rewriteOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFSupportedPredicate(resultIsaArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultIsaArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultIsaArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultIsaArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultIsaArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(resultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultGenlArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultGenlArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(resultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(resultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(resultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(requiredArg3Pred),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(requiredArg2Pred),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(requiredArg1Pred),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationMemberInstance),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationInstanceMember),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationInstanceExists),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationInstanceAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(relationExpansion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationExistsMinAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationExistsMaxAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationExistsInstance),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationExistsCountAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationExistsAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationAllInstance),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationAllExistsMin),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationAllExistsMax),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(relationAllExistsCount),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(relationAllExists),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(relationAll),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulatorRuleProperties),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(reformulatorRuleProperties),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulatorRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(reformulatorRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulationRulePredicate(reformulatorRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulatorEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(reformulatorEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulationRulePredicate(reformulatorEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulatorEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(reformulatorEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulationRulePredicate(reformulatorEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(reformulationPrecondition),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulationPrecondition),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(reformulationDirectionInMode),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(reformulationDirectionInMode),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(ratioOfTo),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(quotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(quotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(quotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(quotedDefnSufficient),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(quotedDefnSufficient),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(quotedDefnNecessary),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(quotedDefnNecessary),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(quotedDefnIff),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(quotedDefnIff),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFSupportedPredicate(quotedArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(quotedArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(querySentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiSymmetricBinaryPredicate(quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(prettyString),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(preservesGenlsInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(predicateConventionMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(predicateConventionMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFSupportedPredicate(pragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtExceptionPredicate(pragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(pragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(pragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(pragmaticallyNormal),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(pragmaticallyNormal),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(pointQuantValue),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(performSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(performSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(overlappingExternalConcept),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(or),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(or),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(or),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(or),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(operatorFormulas),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFSupportedPredicate(openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(opaqueArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(omitArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDocumentationPredicate(oldConstantName),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(oldConstantName),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(oldConstantName),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(nthSmallestElement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(nthLargestElement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(notAssertibleMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(notAssertibleMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(notAssertibleCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(notAssertibleCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(notAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(notAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryRelation(not),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(not),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nonAbducibleWithValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(negationPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(negationPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(negationPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(negationPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(negationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(negationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(negationInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(negationInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(nearestIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(nearestGenls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(nearestGenlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(nearestGenlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestDifferentIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestDifferentGenls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestCommonSpecs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestCommonIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestCommonGenls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(nearestCommonGenlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(natFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(natFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(natArgumentsEqual),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(natArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(natArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(myCreator),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(myCreator),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(myCreator),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(myCreationTime),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(myCreationTime),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(myCreationSecond),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(myCreationSecond),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(myCreationPurpose),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(myCreationPurpose),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(multiplicationUnits),iUniversalVocabularyMt,vStrDef). tiny_kb(rtPartiallyCommutativeRelation(multiplicationUnits),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(mtVisible),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(mtVisible),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(minQuantValue),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(minimizeExtent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(minimize),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(microtheoryDesignationArgnum),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(meetsPragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(meetsPragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(means),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiTransitiveBinaryPredicate(means),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(maxQuantValue),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(knownSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(knownAntecedentRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(knownAntecedentRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtMicrotheoryDesignatingRelation(ist),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(ist),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(isa),iUniversalVocabularyMt,vStrDef). tiny_kb(tReformulatorIrrelevantFORT(isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(irrelevantTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(irrelevantPredAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(irrelevantMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(irrelevantAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgResultIsaReln),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuintaryPredicate(interArgResultIsaReln),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgResultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(interArgResultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgResultGenlReln),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuintaryPredicate(interArgResultGenlReln),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgResultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(interArgResultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuintaryPredicate(interArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgDifferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgDifferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtPartiallyCommutativeRelation(interArgDifferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(interArgDifferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(interArgDifferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(integerBetween),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(instanceElementType),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(instanceElementType),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(indexicalReferent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(independentArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(implies),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(implies),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(hypotheticalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(hypotheticalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(holdsIn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(hlPrototypicalInstance),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(highlyRelevantTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(highlyRelevantPredAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(highlyRelevantMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(highlyRelevantAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiSymmetricBinaryPredicate(greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(greaterThan),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(greaterThan),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(greaterThan),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(genMassNoun),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(genls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(genls),iUniversalVocabularyMt,vStrDef). tiny_kb(tReformulatorIrrelevantFORT(genls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(genls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genls),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(genlRules),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(genlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(genlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(genlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(genlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(genlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(genlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(genlInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genlInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(genlInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(genlCanonicalizerDirectives),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(genKeyword),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(genFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(forwardNonTriggerLiteral),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(formulaArity),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuantifier(all),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(all),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(followingValue),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(followingValue),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(fanOutArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(fanOutArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(extentCardinality),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryPredicate(extConceptOverlapsColAndReln),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(expresses),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(expansionDefn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(expansion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulationRulePredicate(expansion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(expansion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtExceptionPredicate(exceptWhen),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(exceptWhen),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(exceptMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtExceptionPredicate(exceptFor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(exceptFor),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(except),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDocumentationPredicate(exampleAssertions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(exampleAssertions),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(exactlyAssertedEL_next),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(evaluationResultQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(evaluationResultQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(evaluationDefn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(evaluationDefn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(evaluateImmediately),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(evaluateAtEL),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(evaluate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(equiv),iUniversalVocabularyMt,vStrDef). tiny_kb(iELRelationOneWay(equiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(equiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryRelation(equiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(equiv),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(equalSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(equalSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(equalSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(equals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(equals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(equals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(equals),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(ephemeralTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBookkeepingPredicate(ephemeralTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(elInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(elInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiTransitiveBinaryPredicate(elInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(elementOf),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(distributesOutOfArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(disjointWith),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(disjointWith),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(disjointWith),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(differentSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(differentSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(differentSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(different),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(different),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(different),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAsymmetricBinaryPredicate(denotes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiTransitiveBinaryPredicate(denotes),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(defnSufficient),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(defnSufficient),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(defnNecessary),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(defnNecessary),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintSatisfactionPredicate(defnIff),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(defnIff),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(definingMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(definingMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(defaultReformulatorModePrecedence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(defaultReformulatorModePrecedence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(defaultReformulationDirectionInModeForPred),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReformulatorDirectivePredicate(defaultReformulationDirectionInModeForPred),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(decontextualizedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(decontextualizedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(decontextualizedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycTransformationProofRule),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycTransformationProofBindings),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(cycTacticID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(cycProofID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreTerms),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreProofs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreProofCount),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreProblems),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreProblemCount),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreLinks),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreLinkCount),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreInferences),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreInferenceCount),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemStoreID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemQueryTerms),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemQuerySentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(cycProblemLinkID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(cycProblemID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemDependentLinks),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycProblemArgumentLinks),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycInferenceRelevantProblems),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(cycInferenceAnswerLink),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(constraint),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(constrainsArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(constrainsArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(constantName),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(constantID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(constantGUID),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(consistent),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIrreflexiveBinaryPredicate(conceptuallyRelated),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completelyEnumerableCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completelyDecidableCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completeExtentEnumerableViaBackchain),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(completeExtentEnumerableViaBackchain),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(completeExtentEnumerableForValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(completeExtentEnumerableForArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completeExtentEnumerable),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(completeExtentEnumerable),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(completeExtentDecidableForValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completeExtentDecidable),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(completeExtentAssertedForValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(completeExtentAsserted),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(commutativeInArgsAndRest),iUniversalVocabularyMt,vStrDef). tiny_kb(tPred(commutativeInArgsAndRest),iUniversalVocabularyMt,vStrDef). tiny_kb(rtPartiallyCommutativeRelation(commutativeInArgsAndRest),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(commutativeInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtPartiallyCommutativeRelation(commutativeInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(commutativeInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDocumentationPredicate(comment),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDistributingMetaKnowledgePredicate(comment),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(comment),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(comment),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionIsaBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionIsaBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionGenlsBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionGenlsBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(collectionExpansion),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(collectionConventionMt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionCompletelyEnumerableViaBackchain),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(collectionBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(collectionBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(coExtensional),iUniversalVocabularyMt,vStrDef). tiny_kb(rtSymmetricBinaryPredicate(coExtensional),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(coExtensional),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(canonicalizerDirectiveForArgAndRest),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(canonicalizerDirectiveForArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(canonicalizerDirectiveForAllArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(backchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(backchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(backchainForbiddenWhenUnboundInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(backchainForbidden),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(backchainForbidden),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(assertionUtility),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(assertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(assertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(assertedTermSentences),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(call_u_no_bc),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(assertedPredicateArg),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arityMin),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arityMin),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arityMax),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arityMax),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arity),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arity),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argsQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(argsQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(argSometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argSometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeTernaryPredicate(argSometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(argSometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argsIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(argsIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argsGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(argsGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(argQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaTernaryPredicate(argQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaTernaryPredicate(argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argAndRestQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaTernaryPredicate(argAndRestQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(argAndRestIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argAndRestIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaTernaryPredicate(argAndRestIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(argAndRestGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(argAndRestGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlTernaryPredicate(argAndRestGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg6SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg6SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg6SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg6SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg6QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg6QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg6QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg6Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg6Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg6Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg6Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg6Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg6Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg5SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg5SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg5SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg5SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg5QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg5QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg5QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg5Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg5Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg5Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg5Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg5Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg5Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg5Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg5Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg5Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg4SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg4SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg4SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg4SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg4QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg4QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg4QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg4Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg4Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg4Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg4Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg4Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg4Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg4Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg4Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg4Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg3SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg3SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg3SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg3SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg3QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg3QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg3QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg3Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg3Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg3Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg3Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg3Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg3Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg2SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg2SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg2SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg2SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg2QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg2QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg2QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg2Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg2Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg2Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg2Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg2Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg2Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg1SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg1SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypeBinaryPredicate(arg1SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgSometimesIsaPredicate(arg1SometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg1QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg1QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgQuotedIsaBinaryPredicate(arg1QuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg1Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg1Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgIsaBinaryPredicate(arg1Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg1Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(arg1Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgGenlBinaryPredicate(arg1Genl),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(arg1Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(arg1Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgConstraintPredicate(arg1Format),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(and),iUniversalVocabularyMt,vStrDef). tiny_kb(rtLogicalConnective(and),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(and),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(and),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(afterRemoving),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(afterAdding),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(admittedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryPredicate(admittedNAT),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(admittedArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(admittedAllArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(abnormal),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(abnormal),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(wslNonFunctionalParameter),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(wslClassificationRoot),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tWFFSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtWFFSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtWFFDirectivePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtWFFConstraintSatisfactionPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtWFFConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vWednesday),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtVariableAritySkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(cycVariableAritySkolemFuncN),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtUnreifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(vUnknownHLTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(vtHLTruthValue(vUnknownHLTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(mtBroadMicrotheory(iUniversalVocabularyMt),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iUniversalVocabularyImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttUnitOfMeasure(vUnityFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(cycUnitProductFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(cycUnitProductFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(cycUnitProductFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(cycUnitProductFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xUncanonicalizerAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(xUncanonicalizerAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtUnaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttPredicateTypeByArity(rtUnaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtUnaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vTuesday),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vtTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtTruthFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(vtTruthValue(vTrue),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ttTransformationModuleSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ttTransformationModuleSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xTLVariableFn),iUniversalVocabularyMt,vStrDef). tiny_kb(iELRelationOneWay(xTLVariableFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(xTLVariableFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(xTLReifiedNatFn),iUniversalVocabularyMt,vStrDef). tiny_kb(iELRelationOneWay(xTLReifiedNatFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xTLAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtMicrotheoryDesignatingRelation(xTLAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(iELRelationOneWay(xTLAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(xTLAssertionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vTimesFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vTimesFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(vTimesFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(vTimesFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vThursday),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(iTheUser),iUniversalVocabularyMt,vStrDef). tiny_kb(tHumanCyclist(iTheUser),iUniversalVocabularyMt,vStrDef). tiny_kb(mobCyclist(iTheUser),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftTheTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftTheTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(tSetOfTheSetOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtScopingRelation(tSetOfTheSetOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(tSetOfTheSetOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(tSetOfTheSetFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(tSetOfTheSetFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(tSetOfTheSetFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(rtThePrototypicalTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ttThePrototypicalCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(rtThePrototypicalBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vTheListFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(vTheListFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tSetMathematical(iTheEmptySet),iUniversalVocabularyMt,vStrDef). tiny_kb(ftList(vTheEmptyList),iUniversalVocabularyMt,vStrDef). tiny_kb(rtScopingRelation(tColOfTheCollectionOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(tColOfTheCollectionOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCollectionDenotingFunction(tColOfTheCollectionOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(tColOfTheCollectionOfFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtTernaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttPredicateTypeByArity(rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtTernaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(xTemporaryEnglishParaphraseMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ftExpression(xTemporaryEnglishParaphraseMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtSymmetricBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vSunday),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatablePredicate(substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAntiSymmetricBinaryPredicate(substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uSubLQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(uSubLQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonVariableSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonVariableSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonVariableNonKeywordSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonVariableNonKeywordSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftKeyword),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftKeyword),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftCharacter),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftCharacter),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryFunction(iSkolemFunctionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(iSkolemFunctionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tReformulatorIrrelevantFORT(iSkolemFunctionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryFunction(fSkolemFuncNFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(cycSkolemFuncN),iUniversalVocabularyMt,vStrDef). tiny_kb(tWFFSupportedTerm(vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(vtFormat(vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tSet),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttSiblingDisjointAttributeType),iUniversalVocabularyMt,vStrDef). tiny_kb(tWFFSupportedTerm(vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(vtFormat(vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tSetMathematical),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vSeptember),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtSententialRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtScopingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtScalarIntegralValue),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vSaturday),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vRoundUpFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vRoundUpFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vRoundDownFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vRoundDownFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vRoundClosestFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vRoundClosestFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFDirectivePredicate(vRelaxArgTypeConstraintsForVariables),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uRelationInstanceExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryFunction(uRelationInstanceExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIndeterminateTermDenotingFunction(uRelationInstanceExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uRelationExistsInstanceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryFunction(uRelationExistsInstanceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIndeterminateTermDenotingFunction(uRelationExistsInstanceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uRelationExistsAllFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryFunction(uRelationExistsAllFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIndeterminateTermDenotingFunction(uRelationExistsAllFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uRelationAllExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtQuaternaryFunction(uRelationAllExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtIndeterminateTermDenotingFunction(uRelationAllExistsFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tReformulatorIrrelevantFORT),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tReformulatorHighlyRelevantFORT),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtReformulatorDirectivePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tThing(vReformulationNeitherDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(tThing(vReformulationForwardDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(tThing(vReformulationBackwardDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtReflexiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vQuotientFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vQuotientFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tWFFSupportedTerm(xQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(xQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttPredicateTypeByArity(rtQuintaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuintaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuintaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iQueryMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuaternaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttPredicateTypeByArity(rtQuaternaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuaternaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuaternaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tWFFSupportedTerm(xQuasiQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xQuasiQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(xQuasiQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vQuantityConversionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vQuantityConversionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtQuantifier),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(mtProblemSolvingCntxt),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(prettyStringCanonical),iUniversalVocabularyMt,vStrDef). tiny_kb(ttDisjointCollectionType(ttPredicateTypeByArity),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vPlusFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vPlusFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(vPlusFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(vPlusFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vPlusAllFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vPlusAllFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(cycPerFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(cycPerFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vPercentFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vPercentFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtPartiallyCommutativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tOpenInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vOctober),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vNovember),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vNoGoodProblemProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vNeutralProblemProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(tRuleTemplate('NART'([iCollectionRuleTemplateFn,mtHypotheticalContext])),iUniversalVocabularyMt,vStrDef). tiny_kb((meta_argtypes('NART'([iCollectionRuleTemplateFn,mtHypotheticalContext])),tIndividual('NART')),iUniversalVocabularyMt,vStrDef). tiny_kb(tRuleTemplate('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate])),iUniversalVocabularyMt,vStrDef). tiny_kb((meta_argtypes('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate])),tIndividual('NART')),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tMultigraph),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(mtMtUnionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(mtMtUnionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(mtMtUnionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(mtMtUnionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(mtMtTimeWithGranularityDimFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(mtMtTimeWithGranularityDimFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(mtMtTimeDimFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(mtMtTimeDimFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(mtMtSpaceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(mtMtSpaceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(mtMtSpaceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tSet(vtMonthOfYearType),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtMonthOfYearType),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(vMonotonicallyTrue),iUniversalVocabularyMt,vStrDef). tiny_kb(vtHLTruthValue(vMonotonicallyTrue),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(vMonotonicallyFalse),iUniversalVocabularyMt,vStrDef). tiny_kb(vtHLTruthValue(vMonotonicallyFalse),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vMonday),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vModuloFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vModuloFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vMinRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vMinRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(vMinRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtAssociativeRelation(vMinRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vMinimumFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vMinimumFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtMicrotheoryDesignatingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(iMeaningInSystemFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iMeaningInSystemFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vMay),iUniversalVocabularyMt,vStrDef). tiny_kb(rtVariableArityRelation(vMaxRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vMaxRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtCommutativeRelation(vMaxRangeFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vMaximumFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vMaximumFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vMarch),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iLogicalTruthMt),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iLogicalTruthImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtLogicalConnective),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vLogFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vLogFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcVariableBinding),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcTriplePatternQuery),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcSPARQLQuery),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcSetOfStatements),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcSelecter),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcScalability),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcResource),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcReasoner),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcRdfGraph),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcQueryTransformer),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcQuery),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTransitiveBinaryPredicate(larkcPluginByDataConnectsTo),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcPlugin),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcNaturalLanguageDocument),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcLabelledGroupOfStatements),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcKeywordQuery),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcInformationSetTransformer),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcInformationSet),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcIdentifier),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasUri),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasScalability),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasOutputType),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasInputType),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasEndpoint),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(larkcHasCostPerInvocation),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcGateTransformer),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcEuro),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcDecider),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcDataSet),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcCycSelecter),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcCycReasoner),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcCycGateDecider),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcCost),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcBooleanInformationSet),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(larkcArticleIdentifier),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tKnowledgeBase),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(iKappaFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtScopingRelation(iKappaFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iKappaFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vJune),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vJuly),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vJanuary),iUniversalVocabularyMt,vStrDef). tiny_kb(rtMicrotheoryDesignatingRelation(istAsserted),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(istAsserted),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtIrreflexiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(vIntervalMinFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vIntervalMinFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(vIntervalMaxFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vIntervalMaxFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtFormat(vIntervalEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtInterArgIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa5_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa5_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa5_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa5_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa5_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa5_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa5_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa5_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa5_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa5_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa5_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa5_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa4_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa4_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa4_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa4_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa4_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa4_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa4_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa4_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa4_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa4_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa4_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa4_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa3_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa3_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa3_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa3_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa3_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa3_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa3_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa3_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa3_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa3_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa3_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa3_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa2_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa2_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa2_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa2_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa2_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa2_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa2_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa2_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa2_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa2_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa2_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa2_1),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa1_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa1_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa1_5),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa1_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa1_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa1_4),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa1_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa1_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa1_3),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgIsa1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgIsa1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgIsaPredicate(interArgIsa1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgGenl1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtTernaryPredicate(interArgGenl1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtArgTypePredicate(interArgGenl1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtInterArgFormatPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtWFFConstraintPredicate(interArgFormat1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(rtInterArgFormatPredicate(interArgFormat1_2),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(rtInferenceSupportedFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtInferenceSupportedFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ttInferenceSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtInferenceRelatedBookkeepingPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(mtProblemSolvingCntxt(iInferencePSC),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtIndeterminateTermDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(mtHypotheticalContext),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tHumanCyclist),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(xtHLExternalIDString),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tHLAssertedArgumentKeywordDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tHumanCyclist(vGuest),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vGoodProblemProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genlsSpecdenotesgenlinstances),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(genlsSpecdenotesgenlinstances),iUniversalVocabularyMt,vStrDef). tiny_kb(rtDefaultMonotonicPredicate(genlsGenldenotesspecinstances),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(genlsGenldenotesspecinstances),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(iFunctionToArgFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iFunctionToArgFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(vtDayOfWeekType(vFriday),iUniversalVocabularyMt,vStrDef). tiny_kb(vtAssertionDirection(vForwardAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vFormulaArityFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vFormulaArityFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(tSetOfFormulaArgSetFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(tSetOfFormulaArgSetFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vFormulaArgListFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vFormulaArgListFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(uFormulaArgFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uFormulaArgFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uFOLTermFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(uFOLTermFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(iFOLPredicateFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iFOLPredicateFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(iFOLFunctionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iFOLFunctionFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtFixedAritySkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(cycFixedAritySkolemFuncN),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vFebruary),iUniversalVocabularyMt,vStrDef). tiny_kb(vtTruthValue(vFalse),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vExpFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vExpFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uExpandSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uExpandSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vExistentialQuantifierBounded),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtExistentialQuantifier),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtExceptionPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(mtProblemSolvingCntxt(iEverythingPSC),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(uEvaluateSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(uEvaluateSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtEvaluatablePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(tWFFSupportedTerm(xEscapeQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(xEscapeQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(xEscapeQuoteFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReflexiveBinaryPredicate(equalStringsCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iEnglishParaphraseMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(iELRelationReversible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(iELRelationOneWay),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtELRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtDocumentationPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtDistributingMetaKnowledgePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttDisjointCollectionType),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tDirectedMultigraph),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vDifferenceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vDifferenceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(vDefaultTrue),iUniversalVocabularyMt,vStrDef). tiny_kb(vtHLTruthValue(vDefaultTrue),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtDefaultMonotonicPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tIndividual(vDefaultFalse),iUniversalVocabularyMt,vStrDef). tiny_kb(vtHLTruthValue(vDefaultFalse),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vDecember),iUniversalVocabularyMt,vStrDef). tiny_kb(tSet(vtDayOfWeekType),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(xDateEncodeStringFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(xDateEncodeStringFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(iTimeOf_DateDecodeStringFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iTimeOf_DateDecodeStringFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycTransformationProof),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uCycTacticFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uCycTacticFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycSupportDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vtProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uCycProofFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uCycProofFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uCycProblemStoreFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(uCycProblemStoreFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uCycProblemLinkFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uCycProblemLinkFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkUnion),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkTransformation),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkStructural),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkSplit),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkRestriction),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkRemoval),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkLogical),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkJoinOrdered),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkJoin),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkDisjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkContent),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkConjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLinkAnswerLink),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnreifiableFunction(uCycProblemFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(uCycProblemFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftTruthValueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftTruthValueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftRepresentedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftRepresentedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftRepresentedAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftRepresentedAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftReifiedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftReifiedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtReformulationRulePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftPropositionalSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftPropositionalSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftCycLOpenExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftCycLOpenExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonAtomicTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicTermAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonAtomicTermAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftNonAtomicReifiedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftNonAtomicReifiedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iAuthorDefinitionalMt),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(mobCyclist),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftGenericRelationFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftGenericRelationFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftGAFAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftGAFAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftExpressionAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftExpressionAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftExpressionAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftExpressionAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftDenotationalTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftDenotationalTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftDeducedAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftDeducedAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftClosedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftClosedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftClosedNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftClosedNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftClosedFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftClosedFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftClosedAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftClosedAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(tSet(vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttExpressionType(ftAssertedAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ftAssertedAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftKBDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vtInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(iCycInferenceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(iCycInferenceFn),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycInferenceBindingsDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycInferenceAnswerJustification),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycInferenceAnswer),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vtHLTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycHLSupportDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycDeductionDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tCycArgumentDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(tHumanCyclist(vAdministrator),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iCurrentWorldDataCollectorMtNonHomocentric),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iCoreCycLMt),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iCoreCycLImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtCommutativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(iCollectionRuleTemplateFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtReifiableFunction(iCollectionRuleTemplateFn),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(vtAssertionDirection(vCodeAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(tClosedInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(mtBroadMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtBookkeepingPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tMicrotheory(iBookkeepingMt),iUniversalVocabularyMt,vStrDef). tiny_kb(mtBroadMicrotheory(iBookkeepingMt),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtBinaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(ttPredicateTypeByArity(rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtBinaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(vtAssertionDirection(vBackwardAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vAverageFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryFunction(vAverageFn),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vAugust),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(ttAtemporalNecessarilyEssentialCollectionType),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtAsymmetricBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtAssociativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(rtBinaryPredicate(assertionUtility_1),iUniversalVocabularyMt,vStrDef). tiny_kb(tHLAssertedArgumentKeywordDatastructure(vAssertedTrueMonotonic),iUniversalVocabularyMt,vStrDef). tiny_kb(tHLAssertedArgumentKeywordDatastructure(vAssertedTrueDefault),iUniversalVocabularyMt,vStrDef). tiny_kb(tHLAssertedArgumentKeywordDatastructure(vAssertedFalseMonotonic),iUniversalVocabularyMt,vStrDef). tiny_kb(tHLAssertedArgumentKeywordDatastructure(vAssertedFalseDefault),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgTypeTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgTypePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgTypeBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtArgSometimesIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgQuotedIsaTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtArgQuotedIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtArgQuotedIsaBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgIsaTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(tCol(rtArgIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgIsaBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgGenlTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgGenlQuantityTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgGenlQuantityBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgGenlBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtArgConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(vtMonthOfYearType(vApril),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtAntiTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(ttAtemporalNecessarilyEssentialCollectionType(rtAntiSymmetricBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(rtUnaryFunction(vAbsoluteValueFn),iUniversalVocabularyMt,vStrDef). tiny_kb(rtEvaluatableFunction(vAbsoluteValueFn),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtWFFSupportedPredicate,tWFFSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtWFFDirectivePredicate,rtWFFSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtWFFConstraintSatisfactionPredicate,rtWFFSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtWFFConstraintPredicate,rtWFFSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vWednesday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtVariableAritySkolemFunction,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtVariableAritySkolemFunction,rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycVariableAritySkolemFuncN,rtVariableAritySkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycVariableAritySkolemFuncN,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycVariableAritySkolemFuncN,cycSkolemFuncN),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtVariableArityRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnreifiableFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttUnitOfMeasure,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttUnitOfMeasure,rtUnreifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnaryRelation,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnaryPredicate,rtUnaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnaryPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnaryFunction,rtUnaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtUnaryFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vTuesday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtTruthValue,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTruthFunction,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTransitiveBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTransformationModuleSupportedPredicate,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTransformationModuleSupportedPredicate,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttTransformationModuleSupportedCollection,ttInferenceSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vThursday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftTheTerm,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTernaryRelation,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTernaryPredicate,rtTernaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTernaryPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTernaryFunction,rtTernaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtTernaryFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtSymmetricBinaryPredicate,rtCommutativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtSymmetricBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vSunday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSymbol,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSymbol,ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSymbol,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftString,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftString,ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRealNumber,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRealNumber,ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftPositiveInteger,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftPositiveInteger,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonVariableSymbol,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonVariableSymbol,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonVariableSymbol,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonVariableNonKeywordSymbol,ftNonVariableSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftList,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftKeyword,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftKeyword,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftKeyword,ftNonVariableSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftInt,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttExpressionType,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCharacter,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCharacter,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtom,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtSkolemFunction,rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtSkolemFunction,rtIndeterminateTermDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycSkolemFuncN,rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tSet,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttSiblingDisjointAttributeType,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttSetOrCollection,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tSetMathematical,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vSeptember,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtSententialRelation,rtTruthFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtScopingRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtScalarPointValue,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtScalarInterval,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtScalarIntegralValue,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vSaturday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tRuleTemplate,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtRemovalModuleSupportedPredicateSpecific,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtRemovalModuleSupportedPredicateSpecific,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtRemovalModuleSupportedPredicateGeneric,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtRemovalModuleSupportedPredicateGeneric,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttRemovalModuleSupportedCollectionGeneric,ttInferenceSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tRelation,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtReifiableFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tReformulatorIrrelevantFORT,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tReformulatorHighlyRelevantFORT,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtReformulatorDirectivePredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtReflexiveBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRealNumber,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuintaryRelation,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuintaryPredicate,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuintaryPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuintaryFunction,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuintaryFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuaternaryRelation,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuaternaryPredicate,rtQuaternaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuaternaryPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuaternaryFunction,rtQuaternaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuaternaryFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuantifier,rtSententialRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtQuantifier,rtScopingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(mtProblemSolvingCntxt,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttPredicateTypeByArity,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tPred,rtTruthFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftPositiveInteger,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtPartiallyCommutativeRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tOpenInferenceProblemLinkStatus,vtInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vOctober,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vNovember,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonNegativeScalarInterval,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonNegativeInteger,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vNoGoodProblemProvabilityStatus,vtProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vNeutralProblemProvabilityStatus,vtProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tMultigraph,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtMonthOfYearType,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vMonday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtMicrotheoryDesignatingRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tMicrotheory,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vMay,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vMarch,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtLogicalConnective,rtSententialRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftList,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tKnowledgeBase,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vJune,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vJuly,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vJanuary,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtIrreflexiveBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInterArgIsaPredicate,rtArgIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInterArgFormatPredicate,rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInterArgFormatPredicate,rtArgConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftInt,vtScalarIntegralValue),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftInt,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftInferenceSupportedTerm,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInferenceSupportedPredicate,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInferenceSupportedFunction,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttInferenceSupportedCollection,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtInferenceRelatedBookkeepingPredicate,rtBookkeepingPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tIndividual,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtIndeterminateTermDenotingFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftIndeterminateTerm,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(mtHypotheticalContext,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tHumanCyclist,mobCyclist),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftHLPrototypicalTerm,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(xtHLExternalIDString,ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tHLAssertedArgumentKeywordDatastructure,tCycArgumentDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vGoodProblemProvabilityStatus,vtProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tFunction,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vFriday,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vForwardAssertionDirection,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtFormat,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtFixedAritySkolemFunction,rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtFixedAritySkolemFunction,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycFixedAritySkolemFuncN,cycSkolemFuncN),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(cycFixedAritySkolemFuncN,rtFixedAritySkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtFixedArityRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vFebruary,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vExistentialQuantifierBounded,rtTernaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vExistentialQuantifierBounded,rtExistentialQuantifier),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtExistentialQuantifier,rtQuantifier),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtExceptionPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatableRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatablePredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatablePredicate,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatableFunction,rtUnreifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatableFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtEvaluatableFunction,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(iELRelationReversible,rtELRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(iELRelationOneWay,rtELRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtELRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtDocumentationPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDocumentationConstant,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtDistributingMetaKnowledgePredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttDisjointCollectionType,tSet),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tDirectedMultigraph,tMultigraph),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtDefaultMonotonicPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vDecember,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtDayOfWeekType,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycTransformationProof,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycTactic,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycSupportDatastructure,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtProvabilityStatus,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProof,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tProblemStore,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkUnion,tCycProblemLinkDisjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkTransformation,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkStructural,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkSplit,tCycProblemLinkConjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkRestriction,tCycProblemLinkStructural),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkRemoval,tCycProblemLinkContent),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkLogical,tCycProblemLinkStructural),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkJoinOrdered,tCycProblemLinkConjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkJoin,tCycProblemLinkConjunctive),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkDisjunctive,tCycProblemLinkLogical),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkContent,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkConjunctive,tCycProblemLinkLogical),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLinkAnswerLink,tCycProblemLinkStructural),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblemLink,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycProblem,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftVar,ftRepresentedAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftVar,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftVar,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftTruthValueSentence,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftTruthValueSentence,ftClosedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftExpression,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentenceAssertible,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentenceAssertible,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentenceAssertible,ftExpressionAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentenceAskable,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentenceAskable,ftExpressionAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRuleAssertion,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRepresentedTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRepresentedAtomicTerm,ftRepresentedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftRepresentedAtomicTerm,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiedDenotationalTerm,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiedDenotationalTerm,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableNonAtomicTerm,ftClosedNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableDenotationalTerm,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftReifiableDenotationalTerm,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtReformulationRulePredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftPropositionalSentence,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftPropositionalSentence,ftClosedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftCycLOpenExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftCycLOpenExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLOpenExpression,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLOpenExpression,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDenotationalTerm,ftCycLOpenExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDenotationalTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAssertible,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAssertible,ftNonAtomicTermAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAssertible,ftExpressionAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAssertible,ftDenotationalTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAskable,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAskable,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTermAskable,ftExpressionAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftRepresentedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicReifiedTerm,ftReifiedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicReifiedTerm,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicReifiedTerm,ftClosedNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftNonAtomicReifiedTerm,ftKBDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(mobCyclist,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftIndexedTerm,ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftGenericRelationFormula,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftGenericRelationFormula,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftGAFAssertion,ftClosedAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftGAFAssertion,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftGAFAssertion,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftSentence,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttExpressionType,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftExpressionAssertible,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftExpressionAssertible,ftExpressionAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftExpressionAskable,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftExpressionAskable,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLExpression,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLExpression,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDenotationalTermAssertible,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDenotationalTerm,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDenotationalTerm,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftDeducedAssertion,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftConstant,ftRepresentedAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftConstant,ftReifiedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftConstant,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedSentence,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedSentence,ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedNonAtomicTerm,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedNonAtomicTerm,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedNonAtomicTerm,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedNonAtomicTerm,ftClosedFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedNonAtomicTerm,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedFormula,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedFormula,ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLClosedExpression,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftCycLClosedExpression,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedDenotationalTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedDenotationalTerm,ftCycLClosedExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedAtomicSentence,ftClosedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedAtomicSentence,ftClosedFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftClosedAtomicSentence,ftAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftDenotationalTermAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicTerm,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicSentence,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicAssertion,ftAtomicSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAtomicAssertion,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtAssertionDirection,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAssertion,tCycSupportDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAssertion,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAssertion,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftAssertedAssertion,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftKBDatastructure,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtInferenceProblemLinkStatus,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ftInferenceDataStructure,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycInferenceBindingsDataStructure,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycInferenceAnswerJustification,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycInferenceAnswer,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycInference,ftInferenceDataStructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtHLTruthValue,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycHLSupportDatastructure,tCycSupportDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycHLSupportDatastructure,ftKBDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycDeductionDatastructure,tCycArgumentDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCycArgumentDatastructure,ftKBDatastructure),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtCommutativeRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtCollectionDenotingFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tCol,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vCodeAssertionDirection,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(tClosedInferenceProblemLinkStatus,vtInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vtCanonicalizerDirective,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(mtBroadMicrotheory,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBookkeepingPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryRelation,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryPredicate,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryPredicate,rtBinaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryFunction,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtBinaryFunction,rtBinaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vBackwardAssertionDirection,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vAugust,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(ttAtemporalNecessarilyEssentialCollectionType,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtAsymmetricBinaryPredicate,rtIrreflexiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtAsymmetricBinaryPredicate,rtAntiSymmetricBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtAssociativeRelation,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypeTernaryPredicate,rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypeTernaryPredicate,rtArgTypePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypePredicate,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypePredicate,rtArgConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypeBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgTypeBinaryPredicate,rtArgTypePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgSometimesIsaPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgQuotedIsaTernaryPredicate,rtArgTypeTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgQuotedIsaTernaryPredicate,rtArgQuotedIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgQuotedIsaPredicate,rtArgTypePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgQuotedIsaBinaryPredicate,rtArgTypeBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgQuotedIsaBinaryPredicate,rtArgQuotedIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgIsaTernaryPredicate,rtArgTypeTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgIsaTernaryPredicate,rtArgIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgIsaPredicate,rtArgTypePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgIsaBinaryPredicate,rtArgTypeBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgIsaBinaryPredicate,rtArgIsaPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgGenlTernaryPredicate,rtArgTypeTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgGenlQuantityTernaryPredicate,rtArgTypeTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgGenlQuantityBinaryPredicate,rtArgTypeBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgGenlBinaryPredicate,rtArgTypeBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtArgConstraintPredicate,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(vApril,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtAntiTransitiveBinaryPredicate,rtIrreflexiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(genls(rtAntiSymmetricBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(differentSymbols,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(different,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(commutativeInArgsAndRest,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(commutativeInArgs,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(and,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vUnityFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vTimesFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(tSetOfTheSetFn,0),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vPlusFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vPercentFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vMinRangeFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMin(vMaxRangeFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMax(vUnityFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arityMax(vPercentFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xor,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(unknownSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(unitMultiplicationFactor,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(trueSubL,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(trueSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(trueRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(transitiveViaArgInverse,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(transitiveViaArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exists,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(thereExistExactly,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(thereExistAtMost,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(thereExistAtLeast,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(termOfUnit,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(termExternalIDString,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(termDependsOn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(termChosen,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(synonymousExternalConcept,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(substring,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(subsetOf,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(skolemizeForward,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(skolem,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(singleEntryFormatInArgs,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(siblingDisjointExceptions,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(sharedNotes,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(sentenceTruth,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(sentenceImplies,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(sentenceEquiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(sentenceDesignationArgnum,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(scopingArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(salientAssertions,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ruleTemplateDirection,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ruleAfterRemoving,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ruleAfterAdding,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(rewriteOf,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultQuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultIsaArgIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultIsaArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultGenlArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(resultGenl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(requiredArg3Pred,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(requiredArg2Pred,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(requiredArg1Pred,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationMemberInstance,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationInstanceMember,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationInstanceExists,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationInstanceAll,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExpansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExistsMinAll,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExistsMaxAll,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExistsInstance,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExistsCountAll,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationExistsAll,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAllInstance,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAllExistsMin,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAllExistsMax,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAllExistsCount,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAllExists,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(relationAll,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulatorRuleProperties,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulatorRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulatorEquiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulatorEquals,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulationPrecondition,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(reformulationDirectionInMode,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ratioOfTo,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quotedDefnSufficient,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quotedDefnNecessary,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quotedDefnIff,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quotedArgument,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(querySentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quantitySubsumes,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(quantityIntersects,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(prettyString,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(preservesGenlsInArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(predicateConventionMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(pragmaticRequirement,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(pragmaticallyNormal,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(pointQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(performSubL,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(overlappingExternalConcept,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(operatorFormulas,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(openEntryFormatInArgs,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(opaqueArgument,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(omitArgIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(oldConstantName,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(numericallyEquals,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nthSmallestElement,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nthLargestElement,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(notAssertibleMt,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(notAssertibleCollection,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(notAssertible,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(not,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nonAbducibleWithValueInArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(negationPreds,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(negationMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(negationInverse,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestGenls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestGenlPreds,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestGenlMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestDifferentIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestDifferentGenls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestCommonSpecs,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestCommonIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestCommonGenls,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(nearestCommonGenlMt,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(natFunction,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(natArgumentsEqual,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(natArgument,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(myCreator,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(myCreationTime,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(myCreationSecond,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(myCreationPurpose,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(multiplicationUnits,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(mtVisible,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(minQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(minimizeExtent,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(minimize,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(microtheoryDesignationArgnum,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(meetsPragmaticRequirement,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(means,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(maxQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(knownSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(knownAntecedentRule,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ist,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(irrelevantTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(irrelevantPredAssertion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(irrelevantMt,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(irrelevantAssertion,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgResultIsaReln,5),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgResultIsa,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgResultGenlReln,5),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgResultGenl,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa,5),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgDifferent,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(integerBetween,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(instanceElementType,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(indexicalReferent,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(independentArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(implies,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(hypotheticalTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(holdsIn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(hlPrototypicalInstance,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(highlyRelevantTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(highlyRelevantPredAssertion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(highlyRelevantMt,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(highlyRelevantAssertion,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(greaterThanOrEqualTo,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(greaterThan,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genMassNoun,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genls,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlRules,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlPreds,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlInverse,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlCanonicalizerDirectives,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genKeyword,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genFormat,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(forwardNonTriggerLiteral,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(formulaArity,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(all,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(followingValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(fanOutArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(extentCardinality,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(extConceptOverlapsColAndReln,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(expresses,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(expansionDefn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(expansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exceptWhen,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exceptMt,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exceptFor,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(except,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exampleAssertions,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(exactlyAssertedEL_next,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(evaluationResultQuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(evaluationDefn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(evaluateImmediately,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(evaluateAtEL,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(evaluate,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(equiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(equalSymbols,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(equals,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(ephemeralTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(elInverse,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(elementOf,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(distributesOutOfArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(disjointWith,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(denotes,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(defnSufficient,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(defnNecessary,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(defnIff,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(definingMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(defaultReformulationDirectionInModeForPred,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(decontextualizedPredicate,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(decontextualizedCollection,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycTransformationProofRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycTransformationProofBindings,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycTacticID,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProofID,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreTerms,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreProofs,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreProofCount,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreProblems,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreProblemCount,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreLinks,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreLinkCount,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreInferences,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreInferenceCount,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemStoreID,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemQueryTerms,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemQuerySentence,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemProvabilityStatus,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemLinkID,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemID,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemDependentLinks,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycProblemArgumentLinks,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycInferenceRelevantProblems,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycInferenceAnswerLink,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(constraint,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(constrainsArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(constantName,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(constantID,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(constantGUID,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(consistent,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(conceptuallyRelated,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completelyEnumerableCollection,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completelyDecidableCollection,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentEnumerableViaBackchain,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentEnumerableForValueInArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentEnumerableForArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentEnumerable,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentDecidableForValueInArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentDecidable,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentAssertedForValueInArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(completeExtentAsserted,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(comment,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionIsaBackchainRequired,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionIsaBackchainEncouraged,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionGenlsBackchainRequired,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionGenlsBackchainEncouraged,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionExpansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionConventionMt,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionCompletelyEnumerableViaBackchain,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionBackchainRequired,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(collectionBackchainEncouraged,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(coExtensional,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(canonicalizerDirectiveForArgAndRest,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(canonicalizerDirectiveForArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(canonicalizerDirectiveForAllArgs,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(backchainRequired,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(backchainForbiddenWhenUnboundInArg,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(backchainForbidden,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(assertionUtility,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(assertionDirection,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(assertedTermSentences,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(call_u_no_bc,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(assertedPredicateArg,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arityMin,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arityMax,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arity,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argsQuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argSometimesIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argsIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argsGenl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argQuotedIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argAndRestQuotedIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argAndRestIsa,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(argAndRestGenl,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg6SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg6QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg6Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg6Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg6Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg5SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg5QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg5Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg5Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg5Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg4SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg4QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg4Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg4Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg4Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg3SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg3QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg3Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg3Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg3Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg2SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg2QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg2Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg2Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg2Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg1SometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg1QuotedIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg1Isa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg1Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(arg1Format,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(afterRemoving,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(afterAdding,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(admittedSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(admittedNAT,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(admittedArgument,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(admittedAllArgument,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(abnormal,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycUnitProductFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xUncanonicalizerAssertionFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xTLVariableFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xTLReifiedNatFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xTLAssertionFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(tSetOfTheSetOfFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(rtThePrototypicalTransitiveBinaryPredicate,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(rtThePrototypicalBinaryPredicate,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(tColOfTheCollectionOfFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(substringCaseinsensitive,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uSubLQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iSkolemFunctionFn,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(fSkolemFuncNFn,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vRoundUpFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vRoundDownFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vRoundClosestFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uRelationInstanceExistsFn,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uRelationExistsInstanceFn,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uRelationExistsAllFn,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uRelationAllExistsFn,4),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vQuotientFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xQuasiQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vQuantityConversionFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(prettyStringCanonical,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vPlusAllFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(cycPerFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(mtMtTimeWithGranularityDimFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(mtMtTimeDimFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vModuloFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vMinimumFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iMeaningInSystemFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vMaximumFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vLogFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcPluginByDataConnectsTo,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasUri,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasScalability,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasOutputType,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasInputType,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasEndpoint,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(larkcHasCostPerInvocation,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iKappaFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(istAsserted,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vIntervalMinFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vIntervalMaxFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa5_4,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa5_3,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa5_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa5_1,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa4_5,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa4_3,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa4_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa4_1,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa3_5,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa3_4,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa3_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa3_1,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa2_5,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa2_4,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa2_3,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa2_1,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa1_5,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa1_4,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa1_3,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgIsa1_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgGenl1_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(interArgFormat1_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlsSpecdenotesgenlinstances,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(genlsGenldenotesspecinstances,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iFunctionToArgFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vFormulaArityFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(tSetOfFormulaArgSetFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vFormulaArgListFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uFormulaArgFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uFOLTermFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iFOLPredicateFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iFOLFunctionFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vExpFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uExpandSubLFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uEvaluateSubLFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xEscapeQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(equalStringsCaseinsensitive,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vDifferenceFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(xDateEncodeStringFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iTimeOf_DateDecodeStringFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uCycTacticFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uCycProofFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uCycProblemStoreFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uCycProblemLinkFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(uCycProblemFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iCycInferenceFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(iCollectionRuleTemplateFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vAverageFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(assertionUtility_1,2),iUniversalVocabularyMt,vStrDef). tiny_kb(arity(vAbsoluteValueFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(argsQuotedIsa(or,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argsQuotedIsa(differentSymbols,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argsQuotedIsa(and,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(different,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(defaultReformulatorModePrecedence,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vUnityFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vTimesFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(tSetOfTheSetFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vTheListFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vPlusFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vPercentFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(mtMtUnionFn,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(mtMtSpaceFn,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vMinRangeFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argsIsa(vMaxRangeFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,5,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,5,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,5,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa,5,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsaReln,5,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenlReln,5,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(different,5,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,4,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,4,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,4,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,4,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,4,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fSkolemFuncNFn,4,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,4,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgResultIsa,4,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgResultGenl,4,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationExistsAllFn,4,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationAllExistsFn,4,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMinAll,4,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMaxAll,4,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsCountAll,4,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMin,4,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMax,4,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsCount,4,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsaReln,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsa,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenlReln,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenl,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(extConceptOverlapsColAndReln,4,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(different,4,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistExactly,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtMost,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtLeast,3,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulationPrecondition,3,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulationDirectionInMode,3,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,3,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,3,ftSymbol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,3,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,3,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,3,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,3,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(overlappingExternalConcept,3,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,3,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,3,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,3,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,3,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,3,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,3,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,3,rtReformulatorDirectivePredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,3,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,3,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,3,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,3,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,3,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,3,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,3,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,3,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,3,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationInstanceExistsFn,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsInstanceFn,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,3,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,3,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationInstanceExists,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationInstanceAll,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsMinAll,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsMaxAll,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsCountAll,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsAll,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsMin,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsMax,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsCount,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExists,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestDifferentIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestDifferentGenls,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonSpecs,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonGenls,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgResultIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgResultGenl,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argSometimesIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argQuotedIsa,3,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argAndRestQuotedIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argAndRestQuotedIsa,3,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argAndRestIsa,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argAndRestGenl,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationInstanceExistsFn,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationExistsAllFn,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationAllExistsFn,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_4,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_3,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_2,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_1,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_5,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_3,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_2,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_1,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_5,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_4,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_2,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_1,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_5,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_4,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_3,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_1,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_5,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_4,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_3,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_2,3,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(unitMultiplicationFactor,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationInstanceExists,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMinAll,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMaxAll,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsCountAll,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMin,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMax,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsCount,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(multiplicationUnits,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsaReln,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsa,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenlReln,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenl,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgDifferent,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(different,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycTacticID,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProofID,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemLinkID,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemID,3,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argSometimesIsa,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argIsa,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestIsa,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestGenl,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(admittedAllArgument,3,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_4,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_3,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_2,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_1,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_5,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_3,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_2,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_1,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_5,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_4,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_2,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_1,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_5,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_4,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_3,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_1,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_5,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_4,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_3,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_2,3,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xor,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueRule,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exists,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistExactly,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtMost,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(thereExistAtLeast,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termOfUnit,2,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termDependsOn,2,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sharedNotes,2,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceImplies,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceEquiv,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(salientAssertions,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ruleAfterRemoving,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ruleAfterAdding,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(rewriteOf,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(relationExpansion,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRuleProperties,2,ftAtomicAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRule,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquiv,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquals,2,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnSufficient,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnNecessary,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(quotedDefnIff,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(prettyString,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticRequirement,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticallyNormal,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(operatorFormulas,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(oldConstantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgumentsEqual,2,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(meetsPragmaticRequirement,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ist,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantPredAssertion,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(implies,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(holdsIn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantPredAssertion,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genlRules,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genKeyword,2,ftKeyword),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genFormat,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(all,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(expansionDefn,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(expansion,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptWhen,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptFor,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exampleAssertions,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(evaluationDefn,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(equiv,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnSufficient,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnNecessary,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(defnIff,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycTransformationProofRule,2,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemStoreTerms,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemQueryTerms,2,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(cycProblemQuerySentence,2,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(comment,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(collectionExpansion,2,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertedTermSentences,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(arity,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argSometimesIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(argAndRestIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(afterRemoving,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(afterAdding,2,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(abnormal,2,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xTLVariableFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xTLAssertionFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfTheSetOfFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tColOfTheCollectionOfFn,2,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,2,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(prettyStringCanonical,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iKappaFn,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(istAsserted,2,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uFormulaArgFn,2,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uExpandSubLFn,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,2,rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,2,rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termOfUnit,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termExternalIDString,2,xtHLExternalIDString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termDependsOn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substring,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(subsetOf,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(singleEntryFormatInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(siblingDisjointExceptions,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sharedNotes,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceTruth,2,vtTruthValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceDesignationArgnum,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(scopingArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleTemplateDirection,2,vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterRemoving,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterAdding,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(rewriteOf,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArgIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenlArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg3Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg2Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg1Pred,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAll,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRule,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorEquals,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationDirectionInMode,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnSufficient,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnNecessary,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnIff,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantitySubsumes,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantityIntersects,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyString,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(preservesGenlsInArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(predicateConventionMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(overlappingExternalConcept,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(openEntryFormatInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(opaqueArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(omitArgIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(oldConstantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(numericallyEquals,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natFunction,2,rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgumentsEqual,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreator,2,mobCyclist),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationTime,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationSecond,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationPurpose,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(microtheoryDesignationArgnum,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(means,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(maxQuantValue,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(instanceElementType,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(indexicalReferent,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hlPrototypicalInstance,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThanOrEqualTo,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThan,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genls,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlPreds,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,2,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(formulaArity,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(followingValue,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fanOutArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extentCardinality,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expresses,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansionDefn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansion,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationResultQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationDefn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluate,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalSymbols,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equals,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,2,iELRelationOneWay),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elementOf,2,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(disjointWith,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(denotes,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnSufficient,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnNecessary,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnIff,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(definingMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofBindings,2,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreTerms,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofs,2,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblems,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblemCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinkCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferences,2,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferenceCount,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreID,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQueryTerms,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemProvabilityStatus,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemDependentLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemArgumentLinks,2,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceRelevantProblems,2,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceAnswerLink,2,tCycProblemLinkAnswerLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constrainsArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantName,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantID,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantGUID,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(conceptuallyRelated,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForArg,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgsAndRest,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(comment,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionExpansion,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionConventionMt,2,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(coExtensional,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,2,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbiddenWhenUnboundInArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionUtility,2,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionDirection,2,vtAssertionDirection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMin,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMax,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,2,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsQuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsGenl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1SometimesIsa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1QuotedIsa,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Isa,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Genl,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Format,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterRemoving,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterAdding,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,2,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycUnitProductFn,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLVariableFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substringCaseinsensitive,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationInstanceExistsFn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsInstanceFn,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,2,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuotientFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuantityConversionFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyStringCanonical,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,2,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycPerFn,2,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeWithGranularityDimFn,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vModuloFn,2,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinimumFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iMeaningInSystemFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaximumFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsSpecdenotesgenlinstances,2,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsGenldenotesspecinstances,2,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFunctionToArgFn,2,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFormulaArgFn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLPredicateFn,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLFunctionFn,2,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalStringsCaseinsensitive,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vDifferenceFn,2,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xDateEncodeStringFn,2,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iTimeOf_DateDecodeStringFn,2,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycTacticFn,2,tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProofFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemLinkFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCycInferenceFn,2,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAverageFn,2,rtUnaryFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertionUtility_1,2,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(siblingDisjointExceptions,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(resultQuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(resultIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(resultGenl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsMinAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsMaxAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsInstance,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsCountAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationExistsAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllInstance,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsMin,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsMax,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExistsCount,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAllExists,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(relationAll,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(quotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestGenls,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestDifferentGenls,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonSpecs,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonGenls,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(instanceElementType,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(genls,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(evaluationResultQuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(disjointWith,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(cycProblemProvabilityStatus,2,vtProvabilityStatus),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(coExtensional,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argsQuotedIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argsQuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argsIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(argsGenl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg6SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg6QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg6Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg6Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg5SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg5QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg5Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg5Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg4SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg4QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg4Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg4Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg3SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg3QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg3Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg3Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg2SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg2QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg2Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg2Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg1SometimesIsa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg1QuotedIsa,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg1Isa,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(arg1Genl,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(uRelationExistsInstanceFn,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_4,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_3,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_2,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa5_1,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_5,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_3,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_2,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa4_1,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_5,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_4,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_2,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa3_1,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_5,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_4,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_3,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa2_1,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_5,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_4,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_3,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgIsa1_2,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(interArgFormat1_2,2,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(genlsGenldenotesspecinstances,2,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(unitMultiplicationFactor,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(termOfUnit,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(termExternalIDString,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(subsetOf,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(sharedNotes,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(sentenceTruth,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(salientAssertions,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(ruleAfterRemoving,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(ruleAfterAdding,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(rewriteOf,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultQuotedIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultIsaArg,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(requiredArg2Pred,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(requiredArg1Pred,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationInstanceExists,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExpansion,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMinAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMaxAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsCountAll,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMin,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMax,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsCount,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(prettyString,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(pointQuantValue,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(operatorFormulas,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(numericallyEquals,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(negationPreds,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(negationInverse,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(multiplicationUnits,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(minQuantValue,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(means,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(maxQuantValue,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsaReln,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenlReln,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgDifferent,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(independentArg,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(greaterThanOrEqualTo,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(greaterThan,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genls,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genlMt,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genKeyword,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(formulaArity,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(followingValue,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(extentCardinality,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(expresses,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(expansionDefn,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(expansion,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(exampleAssertions,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(evaluationDefn,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(elInverse,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(elementOf,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(disjointWith,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(different,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(denotes,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(defnSufficient,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(defnIff,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(definingMt,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycTransformationProofBindings,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreTerms,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreProofs,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreProofCount,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreProblems,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreProblemCount,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreLinks,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreLinkCount,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreInferences,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreInferenceCount,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemStoreID,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemQueryTerms,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemQuerySentence,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemProvabilityStatus,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemDependentLinks,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycProblemArgumentLinks,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycInferenceRelevantProblems,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycInferenceAnswerLink,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constrainsArg,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constantName,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constantName,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constantID,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(conceptuallyRelated,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(commutativeInArgsAndRest,2,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(comment,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(assertionDirection,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arityMin,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arityMax,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arity,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argSometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argsIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argsGenl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestIsa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestGenl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1SometimesIsa,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1Isa,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1Genl,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(afterAdding,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(admittedAllArgument,2,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(prettyStringCanonical,2,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_4,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_3,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_2,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_1,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_5,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_3,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_2,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_1,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_5,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_4,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_2,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_1,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_5,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_4,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_3,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_1,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_5,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_4,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_3,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_2,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgFormat1_2,2,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xor,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(unknownSentence,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueSubL,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(trueSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exists,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termOfUnit,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termExternalIDString,1,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(termDependsOn,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sharedNotes,1,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceImplies,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(sentenceEquiv,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(salientAssertions,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(rewriteOf,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorRule,1,ftCycLExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquiv,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(reformulatorEquals,1,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(querySentence,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pragmaticRequirement,1,ftSentenceAskable),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(pointQuantValue,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(performSubL,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(or,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(operatorFormulas,1,ftClosedDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(oldConstantName,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(not,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natFunction,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgumentsEqual,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(natArgument,1,ftReifiableNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreator,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreationTime,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreationSecond,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(myCreationPurpose,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(minimize,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(knownSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(knownAntecedentRule,1,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(irrelevantAssertion,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(indexicalReferent,1,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(implies,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hypotheticalTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hlPrototypicalInstance,1,ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(hlPrototypicalInstance,1,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(highlyRelevantAssertion,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genMassNoun,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genlRules,1,ftRuleAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(genKeyword,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(forwardNonTriggerLiteral,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(formulaArity,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(all,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptWhen,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exceptFor,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(except,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exampleAssertions,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(exactlyAssertedEL_next,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(equiv,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(ephemeralTerm,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(definingMt,1,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constraint,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantName,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantID,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(constantGUID,1,ftConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(consistent,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(comment,1,ftIndexedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionUtility,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionDirection,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertedTermSentences,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(call_u_no_bc,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(and,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(admittedSentence,1,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(admittedNAT,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xUncanonicalizerAssertionFn,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfTheSetOfFn,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tColOfTheCollectionOfFn,1,ftVar),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uSubLQuoteFn,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iSkolemFunctionFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(fSkolemFuncNFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xQuasiQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(iKappaFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(vFormulaArityFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(tSetOfFormulaArgSetFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(vFormulaArgListFn,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uExpandSubLFn,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(uEvaluateSubLFn,1,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(xEscapeQuoteFn,1,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argQuotedIsa(assertionUtility_1,1,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(unitMultiplicationFactor,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(trueSubL,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(trueRule,1,tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArgInverse,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(transitiveViaArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistExactly,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistAtMost,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(thereExistAtLeast,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termOfUnit,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termExternalIDString,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termDependsOn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(termChosen,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(synonymousExternalConcept,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substring,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(subsetOf,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(skolemizeForward,1,rtReifiableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(skolem,1,rtSkolemFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(singleEntryFormatInArgs,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(siblingDisjointExceptions,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sharedNotes,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceEquiv,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(sentenceDesignationArgnum,1,rtMicrotheoryDesignatingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(scopingArg,1,rtScopingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(salientAssertions,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleTemplateDirection,1,tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterRemoving,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ruleAfterAdding,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(rewriteOf,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultQuotedIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArgIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsaArg,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenlArg,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(resultGenl,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg3Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg2Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(requiredArg1Pred,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationMemberInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceMember,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceExists,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationInstanceAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExpansion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMinAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsMaxAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsCountAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationExistsAll,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllInstance,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMin,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsMax,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExistsCount,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAllExists,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(relationAll,1,rtUnaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRuleProperties,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorRule,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulatorEquals,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationPrecondition,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(reformulationDirectionInMode,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ratioOfTo,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnSufficient,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnNecessary,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedDefnIff,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quotedArgument,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantitySubsumes,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(quantityIntersects,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyString,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(preservesGenlsInArg,1,rtCollectionDenotingFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(predicateConventionMt,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pragmaticallyNormal,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(pointQuantValue,1,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(performSubL,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(operatorFormulas,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(openEntryFormatInArgs,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(opaqueArgument,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(omitArgIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(oldConstantName,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(numericallyEquals,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthSmallestElement,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nthLargestElement,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertibleMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertibleCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(notAssertible,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nonAbducibleWithValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(negationInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestGenlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestDifferentGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonSpecs,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonIsa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(nearestCommonGenlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natFunction,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgumentsEqual,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(natArgument,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreator,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationTime,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationSecond,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(myCreationPurpose,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(multiplicationUnits,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtVisible,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minQuantValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(minimizeExtent,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(microtheoryDesignationArgnum,1,rtMicrotheoryDesignatingRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(meetsPragmaticRequirement,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(means,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(maxQuantValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ist,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(isa,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantPredAssertion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(irrelevantMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsaReln,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultIsa,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenlReln,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgResultGenl,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgDifferent,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(integerBetween,1,ftInt),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(instanceElementType,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(indexicalReferent,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,1,rtTernaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(independentArg,1,rtArgConstraintPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hypotheticalTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(holdsIn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(hlPrototypicalInstance,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantPredAssertion,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(highlyRelevantMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThanOrEqualTo,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(greaterThan,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genMassNoun,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genls,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlPreds,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlCanonicalizerDirectives,1,vtCanonicalizerDirective),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genKeyword,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genFormat,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(formulaArity,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(followingValue,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(fanOutArg,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extentCardinality,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(extConceptOverlapsColAndReln,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expresses,1,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansionDefn,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(expansion,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exceptMt,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exceptFor,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(exampleAssertions,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationResultQuotedIsa,1,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluationDefn,1,rtEvaluatableRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluateImmediately,1,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluateAtEL,1,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(evaluate,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalSymbols,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equals,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(ephemeralTerm,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elInverse,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(elementOf,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(distributesOutOfArg,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(disjointWith,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(different,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(denotes,1,ftDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnSufficient,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnNecessary,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defnIff,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(definingMt,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulatorModePrecedence,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(defaultReformulationDirectionInModeForPred,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(decontextualizedPredicate,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(decontextualizedCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofRule,1,tCycTransformationProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTransformationProofBindings,1,tCycTransformationProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycTacticID,1,tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProofID,1,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreTerms,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofs,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProofCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblems,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreProblemCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinks,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreLinkCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferences,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreInferenceCount,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemStoreID,1,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQueryTerms,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemQuerySentence,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemProvabilityStatus,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemLinkID,1,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemID,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemDependentLinks,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycProblemArgumentLinks,1,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceRelevantProblems,1,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycInferenceAnswerLink,1,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constrainsArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantName,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantID,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(constantGUID,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(conceptuallyRelated,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completelyEnumerableCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completelyDecidableCollection,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableViaBackchain,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerableForArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentEnumerable,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidableForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentDecidable,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAssertedForValueInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(completeExtentAsserted,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgsAndRest,1,rtPartiallyCommutativeRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(commutativeInArgs,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(comment,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionIsaBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionIsaBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionGenlsBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionGenlsBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionExpansion,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionConventionMt,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionCompletelyEnumerableViaBackchain,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionBackchainRequired,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(collectionBackchainEncouraged,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(coExtensional,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArgAndRest,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForArg,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(canonicalizerDirectiveForAllArgs,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainRequired,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbiddenWhenUnboundInArg,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(backchainForbidden,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedTermSentences,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(assertedPredicateArg,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMin,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arityMax,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arity,1,rtFixedArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsQuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argSometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argsGenl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argQuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestQuotedIsa,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(argAndRestGenl,1,rtVariableArityRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg6Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg5Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg4Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg3Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg2Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1SometimesIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1QuotedIsa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Isa,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Genl,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(arg1Format,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterRemoving,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(afterAdding,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedNAT,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedArgument,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(admittedAllArgument,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(abnormal,1,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vUnityFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycUnitProductFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xUncanonicalizerAssertionFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLVariableFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLReifiedNatFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xTLAssertionFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vTimesFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(tSetOfTheSetFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vTheListFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(substringCaseinsensitive,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundUpFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundDownFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vRoundClosestFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationInstanceExistsFn,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsInstanceFn,1,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationExistsAllFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uRelationAllExistsFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuotientFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xQuasiQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vQuantityConversionFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(prettyStringCanonical,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPlusAllFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(cycPerFn,1,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vPercentFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtUnionFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeWithGranularityDimFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtTimeDimFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(mtMtSpaceFn,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vModuloFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinRangeFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMinimumFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iMeaningInSystemFn,1,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaxRangeFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vMaximumFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vLogFn,1,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vLogFn,1,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(istAsserted,1,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vIntervalMinFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vIntervalMaxFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_4,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_3,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_2,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa5_1,1,rtQuintaryRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa4_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa3_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa2_1,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_5,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_4,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_3,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgIsa1_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgGenl1_2,1,tRelation),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(interArgFormat1_2,1,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsSpecdenotesgenlinstances,1,ttExpressionType),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(genlsGenldenotesspecinstances,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFunctionToArgFn,1,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vFormulaArityFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(tSetOfFormulaArgSetFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vFormulaArgListFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFormulaArgFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uFOLTermFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLPredicateFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iFOLFunctionFn,1,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vExpFn,1,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uEvaluateSubLFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xEscapeQuoteFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(equalStringsCaseinsensitive,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vDifferenceFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(xDateEncodeStringFn,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iTimeOf_DateDecodeStringFn,1,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycTacticFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProofFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemStoreFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemLinkFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(uCycProblemFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCycInferenceFn,1,ftNonNegativeInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(iCollectionRuleTemplateFn,1,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAverageFn,1,ttSetOrCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(argIsa(vAbsoluteValueFn,1,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(siblingDisjointExceptions,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(requiredArg3Pred,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(requiredArg2Pred,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(requiredArg1Pred,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(quotedDefnSufficient,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(quotedDefnNecessary,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(quotedDefnIff,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(notAssertibleCollection,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestGenls,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestDifferentGenls,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonSpecs,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(nearestCommonGenls,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(instanceElementType,1,tSetMathematical),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(genls,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(extConceptOverlapsColAndReln,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(disjointWith,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(defnSufficient,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(defnNecessary,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(defnIff,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(decontextualizedCollection,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(completelyEnumerableCollection,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(completelyDecidableCollection,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionIsaBackchainRequired,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionIsaBackchainEncouraged,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionGenlsBackchainRequired,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionGenlsBackchainEncouraged,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionConventionMt,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionCompletelyEnumerableViaBackchain,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionBackchainRequired,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(collectionBackchainEncouraged,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(coExtensional,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(admittedAllArgument,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(genlsSpecdenotesgenlinstances,1,ftSubLSExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(argGenl(iCollectionRuleTemplateFn,1,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(unitMultiplicationFactor,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(termOfUnit,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(termOfUnit,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(termExternalIDString,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(sharedNotes,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(salientAssertions,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(rewriteOf,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultQuotedIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultIsaArg,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(resultGenl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(requiredArg2Pred,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(requiredArg1Pred,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationInstanceExists,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMinAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsMaxAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationExistsCountAll,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMin,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsMax,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(relationAllExistsCount,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(quotedIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(prettyString,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(pointQuantValue,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(operatorFormulas,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(numericallyEquals,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(negationPreds,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(negationInverse,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(multiplicationUnits,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(minQuantValue,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(minimizeExtent,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(means,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(maxQuantValue,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsaReln,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenlReln,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgResultGenl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgDifferent,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(independentArg,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(greaterThanOrEqualTo,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(greaterThan,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genls,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genlMt,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(genKeyword,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(followingValue,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(expresses,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(evaluationResultQuotedIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(evaluationDefn,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(elInverse,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(elementOf,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(disjointWith,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(different,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(denotes,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(defnSufficient,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(defaultReformulationDirectionInModeForPred,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(cycInferenceAnswerLink,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constrainsArg,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constantName,1,singleEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(constantID,1,vSingleEntry),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(conceptuallyRelated,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(completelyEnumerableCollection,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(completelyDecidableCollection,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(completeExtentEnumerable,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(completeExtentDecidable,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(completeExtentAsserted,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(commutativeInArgsAndRest,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(comment,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arityMin,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arityMax,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arity,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argSometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argsIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argsGenl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestIsa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(argAndRestGenl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg6Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg5Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg4Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg3Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg2Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1SometimesIsa,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1Isa,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1Genl,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(arg1Format,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(admittedAllArgument,1,openEntryFormatInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(prettyStringCanonical,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_4,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_3,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_2,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa5_1,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_5,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_3,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_2,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa4_1,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_5,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_4,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_2,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa3_1,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_5,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_4,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_3,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa2_1,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_5,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_4,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_3,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgIsa1_2,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(argFormat(interArgFormat1_2,1,vSetTheFormat),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(trueSentence,consistent),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(synonymousExternalConcept,overlappingExternalConcept),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(siblingDisjointExceptions,different),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(sentenceEquiv,sentenceImplies),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(rewriteOf,equals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(relationAllExistsCount,relationAllExistsMin),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(relationAllExistsCount,relationAllExistsMax),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(reformulatorEquiv,reformulatorRule),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(reformulatorEquals,reformulatorRule),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(quotedArgument,opaqueArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(quantitySubsumes,quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(pointQuantValue,numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(pointQuantValue,minQuantValue),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(pointQuantValue,maxQuantValue),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(numericallyEquals,quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(numericallyEquals,greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(nearestIsa,isa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(nearestGenls,genls),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(nearestGenlPreds,genlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(nearestGenlMt,genlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(natFunction,termDependsOn),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(minQuantValue,quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(maxQuantValue,quantitySubsumes),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(knownSentence,trueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(knownAntecedentRule,highlyRelevantAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(isa,elementOf),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(indexicalReferent,equals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(greaterThan,greaterThanOrEqualTo),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(greaterThan,different),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(genls,subsetOf),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(followingValue,different),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(expresses,means),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(exactlyAssertedEL_next,call_u_no_bc),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(equalSymbols,equals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(elInverse,genlInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(different,differentSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(denotes,means),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(defnIff,defnSufficient),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(defnIff,defnNecessary),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(definingMt,termDependsOn),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(consistent,admittedSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completelyEnumerableCollection,completelyDecidableCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentEnumerableViaBackchain,minimizeExtent),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentEnumerableForValueInArg,nonAbducibleWithValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentEnumerableForValueInArg,completeExtentDecidableForValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentEnumerable,minimizeExtent),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentEnumerable,completeExtentDecidable),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentDecidable,backchainForbidden),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentAssertedForValueInArg,completeExtentEnumerableForValueInArg),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(completeExtentAsserted,completeExtentEnumerable),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(commutativeInArgsAndRest,commutativeInArgs),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionIsaBackchainRequired,collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionGenlsBackchainRequired,collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionBackchainRequired,collectionIsaBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionBackchainRequired,collectionGenlsBackchainRequired),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionBackchainRequired,collectionBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionBackchainEncouraged,collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(collectionBackchainEncouraged,collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(coExtensional,genls),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(canonicalizerDirectiveForArgAndRest,canonicalizerDirectiveForArg),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(call_u_no_bc,knownSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(assertedPredicateArg,admittedArgument),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(argsIsa,arg1Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(argIsa,argSometimesIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(argAndRestQuotedIsa,argQuotedIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(argAndRestIsa,argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(istAsserted,ist),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(equalStringsCaseinsensitive,equals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlPreds(equalStringsCaseinsensitive,substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyMt,iUniversalVocabularyImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyMt,iCoreCycLImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyImplementationMt,iUniversalVocabularyMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyImplementationMt,iCoreCycLImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iUniversalVocabularyImplementationMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(xTemporaryEnglishParaphraseMt,iEnglishParaphraseMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(xTemporaryEnglishParaphraseMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iQueryMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iLogicalTruthMt,iLogicalTruthImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iLogicalTruthMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iLogicalTruthImplementationMt,iLogicalTruthMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iLogicalTruthImplementationMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iInferencePSC,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iEverythingPSC,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iEnglishParaphraseMt,iCurrentWorldDataCollectorMtNonHomocentric),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iEnglishParaphraseMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iAuthorDefinitionalMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCurrentWorldDataCollectorMtNonHomocentric,iAuthorDefinitionalMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCurrentWorldDataCollectorMtNonHomocentric,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLMt,iLogicalTruthMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLMt,iCoreCycLImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLImplementationMt,iLogicalTruthImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLImplementationMt,iCoreCycLMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iCoreCycLImplementationMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBookkeepingMt,iEnglishParaphraseMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBookkeepingMt,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBaseKB,iUniversalVocabularyMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBaseKB,iUniversalVocabularyImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBaseKB,iCoreCycLImplementationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlMt(iBaseKB,iBaseKB),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(siblingDisjointExceptions,siblingDisjointExceptions),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(sentenceEquiv,sentenceImplies),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(sentenceEquiv,sentenceEquiv),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(reformulatorRuleProperties,isa),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(quantitySubsumes,quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(quantityIntersects,quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(numericallyEquals,numericallyEquals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(negationPreds,negationPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(negationMt,negationMt),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(negationInverse,negationInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(natFunction,operatorFormulas),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(minQuantValue,quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(maxQuantValue,quantityIntersects),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(greaterThan,different),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(followingValue,greaterThan),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(equalSymbols,equalSymbols),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(equals,equals),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(elInverse,genlInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(disjointWith,disjointWith),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(coExtensional,genls),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(coExtensional,coExtensional),iUniversalVocabularyMt,vStrDef). tiny_kb(genlInverse(equalStringsCaseinsensitive,substringCaseinsensitive),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(iELRelationReversible,iELRelationOneWay),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(ftSentence,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(ftSentence,ftGenericRelationFormula),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(ftRepresentedAtomicTerm,ftAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(ftGenericRelationFormula,ftNonAtomicTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(disjointWith(ftAtomicTerm,ftSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vWednesday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vTuesday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vThursday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vSunday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vtScalarPointValue,uSubLQuoteFn('SCALAR-POINT-VALUE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vtScalarInterval,uSubLQuoteFn('IBQE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vSaturday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vMonday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(ftList,uSubLQuoteFn('CYC-LIST-OF-TYPE-SUFFICIENT')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(ftInt,uSubLQuoteFn('INTEGERP')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(vFriday,uSubLQuoteFn('CYC-DAY-OF-WEEK-DEFN')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(ftString,uSubLQuoteFn('STRINGP')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnSufficient(ftString,uSubLQuoteFn('CYC-LIST-OF-TYPE-SUFFICIENT')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnNecessary(tSetMathematical,uSubLQuoteFn('CYC-SET-OF-TYPE-NECESSARY')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnNecessary(ftList,uSubLQuoteFn('CYC-LIST-OF-TYPE-NECESSARY')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnNecessary(tIndividual,uSubLQuoteFn('CYC-INDIVIDUAL-NECESSARY')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnNecessary(ftString,uSubLQuoteFn('CYC-LIST-OF-TYPE-NECESSARY')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(tThing,uSubLQuoteFn('TRUE')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(ftRealNumber,uSubLQuoteFn('CYC-REAL-NUMBER')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(ftPositiveInteger,uSubLQuoteFn('CYC-POSITIVE-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(ftNonNegativeScalarInterval,uSubLQuoteFn('NON-NEGATIVE-SCALAR-INTERVAL?')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(ftNonNegativeInteger,uSubLQuoteFn('CYC-NON-NEGATIVE-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(ftInt,uSubLQuoteFn('CYC-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(defnIff(xtHLExternalIDString,uSubLQuoteFn('HL-EXTERNAL-ID-STRING-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(collectionExpansion(rtTransitiveBinaryPredicate,implies(and(':ARG1'(X,Y),':ARG1'(Y,Z)),':ARG1'(X,Z))),iUniversalVocabularyMt,vStrDef). tiny_kb(collectionExpansion(rtSymmetricBinaryPredicate,implies(':ARG1'(X,Y),':ARG1'(Y,Z))),iUniversalVocabularyMt,vStrDef). tiny_kb(collectionExpansion(rtReflexiveBinaryPredicate,':ARG1'(X,X)),iUniversalVocabularyMt,vStrDef). tiny_kb(collectionExpansion(rtIrreflexiveBinaryPredicate,not(':ARG1'(X,X))),iUniversalVocabularyMt,vStrDef). tiny_kb(collectionExpansion(rtAsymmetricBinaryPredicate,implies(':ARG1'(X,Y),not(':ARG1'(Y,Z)))),iUniversalVocabularyMt,vStrDef). tiny_kb(expansion(genlsSpecdenotesgenlinstances,implies(quotedIsa(OBJ,':ARG1'),':ARG2'(OBJ))),iUniversalVocabularyMt,vStrDef). tiny_kb(expansion(genlsGenldenotesspecinstances,implies(':ARG1'(OBJ),quotedIsa(OBJ,':ARG2'))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,6,COL),argIsa(RELN,6,COL)),implies(argIsa(RELN,6,COL),argIsa(RELN,6,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,5,COL),argIsa(RELN,5,COL)),implies(argIsa(RELN,5,COL),argIsa(RELN,5,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,4,COL),argIsa(RELN,4,COL)),implies(argIsa(RELN,4,COL),argIsa(RELN,4,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,3,COL),argIsa(RELN,3,COL)),implies(argIsa(RELN,3,COL),argIsa(RELN,3,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,2,COL),argIsa(RELN,2,COL)),implies(argIsa(RELN,2,COL),argIsa(RELN,2,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(argIsa(RELN,1,COL),argIsa(RELN,1,COL)),implies(argIsa(RELN,1,COL),argIsa(RELN,1,COL)))),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(interArgResultIsa(FN,_NUM,tThing,COLL),resultIsa(FN,COLL)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(argQuotedIsa(PRED,N,_COL),quotedArgument(PRED,N)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(collectionIsaBackchainRequired(PRED),collectionIsaBackchainEncouraged(PRED)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(collectionGenlsBackchainRequired(PRED),collectionGenlsBackchainEncouraged(PRED)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(collectionBackchainRequired(PRED),collectionBackchainEncouraged(PRED)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(vExistentialQuantifierBounded(QUANT),argQuotedIsa(QUANT,3,ftSentenceAssertible)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(vExistentialQuantifierBounded(QUANT),argQuotedIsa(QUANT,2,ftVar)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(rtTransitiveBinaryPredicate(PRED),transitiveViaArgInverse(PRED,PRED,1)),iUniversalVocabularyMt,vStrDef). tiny_kb(implies(and(natFunction(NAT,FUNC),preservesGenlsInArg(FUNC,NUM),natFunction(INDEP_COLL_NAT,FUNC),genls(TERM,INDEP_COLL),natArgument(NAT,NUM,TERM),natArgument(INDEP_COLL_NAT,NUM,INDEP_COLL)),genls(NAT,INDEP_COLL_NAT)),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsaArgIsa(vIntervalMinFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsaArgIsa(vIntervalMaxFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vUnityFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(cycUnitProductFn,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xUncanonicalizerAssertionFn,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xTLVariableFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xTLVariableFn,ftAtom),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xTLReifiedNatFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xTLReifiedNatFn,ftReifiableDenotationalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xTLAssertionFn,ftAssertion),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vTimesFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(tSetOfTheSetOfFn,tSetMathematical),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(tSetOfTheSetFn,tSetMathematical),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vTheListFn,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(tColOfTheCollectionOfFn,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iSkolemFunctionFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(fSkolemFuncNFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vRoundUpFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vRoundDownFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vRoundClosestFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uRelationInstanceExistsFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uRelationExistsInstanceFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uRelationExistsAllFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uRelationAllExistsFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vQuotientFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xQuoteFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xQuoteFn,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xQuasiQuoteFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xQuasiQuoteFn,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vQuantityConversionFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vPlusFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vPlusAllFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(cycPerFn,ttUnitOfMeasure),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vPercentFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(mtMtUnionFn,mtProblemSolvingCntxt),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(mtMtTimeWithGranularityDimFn,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(mtMtTimeDimFn,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(mtMtSpaceFn,tMicrotheory),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vModuloFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vMinRangeFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vMinimumFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iMeaningInSystemFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vMaxRangeFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vMaximumFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vLogFn,ftRealNumber),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iKappaFn,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vIntervalMinFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vIntervalMaxFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iFunctionToArgFn,rtEvaluatableFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vFormulaArityFn,ftPositiveInteger),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(tSetOfFormulaArgSetFn,tSetMathematical),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vFormulaArgListFn,ftList),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uFormulaArgFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uFOLTermFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iFOLPredicateFn,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iFOLFunctionFn,tFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vExpFn,vtScalarPointValue),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uEvaluateSubLFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xEscapeQuoteFn,tThing),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xEscapeQuoteFn,ftExpression),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vDifferenceFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(xDateEncodeStringFn,ftString),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iTimeOf_DateDecodeStringFn,tIndividual),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uCycTacticFn,tCycTactic),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uCycProofFn,tCycProof),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uCycProblemStoreFn,tProblemStore),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uCycProblemLinkFn,tCycProblemLink),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(uCycProblemFn,tCycProblem),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iCycInferenceFn,tCycInference),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(iCollectionRuleTemplateFn,tRuleTemplate),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vAverageFn,vtScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(resultIsa(vAbsoluteValueFn,ftNonNegativeScalarInterval),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(unknownSentence,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(trueSentence,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(transitiveViaArgInverse,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(transitiveViaArg,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(transitiveViaArg,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(termOfUnit,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(termExternalIDString,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(termChosen,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(subsetOf,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(skolemizeForward,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(siblingDisjointExceptions,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(sentenceImplies,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(sentenceEquiv,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(ruleAfterRemoving,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(ruleAfterAdding,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationInstanceExists,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationInstanceAll,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationExistsInstance,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationExistsAll,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationAllInstance,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationAllExists,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(relationAll,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(quotedIsa,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(quotedArgument,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(pragmaticRequirement,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(performSubL,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(operatorFormulas,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nthSmallestElement,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nthLargestElement,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(negationPreds,rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(negationPreds,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(negationPreds,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(negationInverse,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestIsa,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestGenls,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestGenlPreds,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestGenlMt,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestDifferentIsa,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestDifferentGenls,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestCommonSpecs,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestCommonIsa,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestCommonGenls,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(nearestCommonGenlMt,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(natFunction,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(natArgumentsEqual,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(natArgument,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreator,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreator,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationTime,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationTime,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationSecond,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationSecond,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationPurpose,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(myCreationPurpose,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(minQuantValue,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(minimizeExtent,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(maxQuantValue,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(knownSentence,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(ist,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(isa,rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(isa,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(isa,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(interArgDifferent,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(integerBetween,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(indexicalReferent,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(hlPrototypicalInstance,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genls,rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genls,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genls,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlPreds,rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlPreds,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlPreds,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlPreds,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlMt,rtTransformationModuleSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlMt,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlInverse,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlInverse,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlInverse,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(forwardNonTriggerLiteral,rtInferenceSupportedPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(formulaArity,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(extentCardinality,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(exactlyAssertedEL_next,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(evaluationDefn,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(evaluate,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(equalSymbols,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(equals,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(elInverse,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(elementOf,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(disjointWith,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(disjointWith,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(differentSymbols,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(different,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycTransformationProofRule,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycTransformationProofBindings,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreTerms,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreProofCount,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreProblems,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreProblemCount,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreLinkCount,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemStoreInferenceCount,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemQueryTerms,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemQuerySentence,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(cycProblemProvabilityStatus,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(constantName,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(constantID,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(constantGUID,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(consistent,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(conceptuallyRelated,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentEnumerableForValueInArg,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentEnumerableForArg,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentEnumerable,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentDecidableForValueInArg,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentDecidable,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentAssertedForValueInArg,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(completeExtentAsserted,rtRemovalModuleSupportedPredicateGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(comment,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(assertionDirection,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(assertedTermSentences,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(call_u_no_bc,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(assertedPredicateArg,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(arityMax,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(arity,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(argAndRestIsa,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(afterAdding,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(admittedSentence,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(admittedArgument,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(vTrue,ftTruthValueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(vTrue,ftSentenceAssertible),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtTransitiveBinaryPredicate,ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(iTheUser,ftTheTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtThePrototypicalTransitiveBinaryPredicate,ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(ttThePrototypicalCollection,ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtThePrototypicalBinaryPredicate,ftHLPrototypicalTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(tColOfTheCollectionOfFn,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtSymmetricBinaryPredicate,ttTransformationModuleSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtSymmetricBinaryPredicate,ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(ftPositiveInteger,ttInferenceSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtReflexiveBinaryPredicate,ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(xQuoteFn,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(iQueryMt,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(xQuasiQuoteFn,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(iKappaFn,rtInferenceSupportedFunction),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(istAsserted,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtIrreflexiveBinaryPredicate,ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(vGuest,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlsSpecdenotesgenlinstances,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(genlsGenldenotesspecinstances,tPred),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(vFalse,ftTruthValueSentence),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(xEscapeQuoteFn,ftInferenceSupportedTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(equalStringsCaseinsensitive,rtRemovalModuleSupportedPredicateSpecific),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtDocumentationPredicate,ftDocumentationConstant),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(vAdministrator,ftIndeterminateTerm),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtAsymmetricBinaryPredicate,ttTransformationModuleSupportedCollection),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedIsa(rtAsymmetricBinaryPredicate,ttRemovalModuleSupportedCollectionGeneric),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSymbol,uSubLQuoteFn('SYMBOLP')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftString,uSubLQuoteFn('CYC-SYSTEM-STRING-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSubLSExpression,uSubLQuoteFn('CYC-SUBL-EXPRESSION')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftRealNumber,uSubLQuoteFn('CYC-SYSTEM-REAL-NUMBER-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftPositiveInteger,uSubLQuoteFn('CYC-POSITIVE-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonVariableSymbol,uSubLQuoteFn('CYC-SYSTEM-NON-VARIABLE-SYMBOL-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonVariableNonKeywordSymbol,uSubLQuoteFn('SUBL-NON-VARIABLE-NON-KEYWORD-SYMBOL-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonNegativeInteger,uSubLQuoteFn('CYC-NON-NEGATIVE-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftList,uSubLQuoteFn('LISTP')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftKeyword,uSubLQuoteFn('KEYWORDP')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftInt,uSubLQuoteFn('CYC-SYSTEM-INTEGER')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftCharacter,uSubLQuoteFn('CYC-SYSTEM-CHARACTER-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtomicTerm,uSubLQuoteFn('CYC-SYSTEM-TERM-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtom,uSubLQuoteFn('CYC-SYSTEM-ATOM')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftVar,uSubLQuoteFn('CYCL-VARIABLE-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftExpression,uSubLQuoteFn('CYCL-EXPRESSION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentenceAssertible,uSubLQuoteFn('CYCL-SENTENCE-ASSERTIBLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentenceAskable,uSubLQuoteFn('CYCL-SENTENCE-ASKABLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentence,uSubLQuoteFn('CYCL-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftRuleAssertion,uSubLQuoteFn('CYCL-RULE-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftRepresentedTerm,uSubLQuoteFn('CYCL-REPRESENTED-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftRepresentedAtomicTerm,uSubLQuoteFn('CYCL-REPRESENTED-ATOMIC-TERM-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftReifiedDenotationalTerm,uSubLQuoteFn('CYCL-REIFIED-DENOTATIONAL-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftReifiableNonAtomicTerm,uSubLQuoteFn('CYCL-REIFIABLE-NON-ATOMIC-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftReifiableDenotationalTerm,uSubLQuoteFn('CYCL-REIFIABLE-DENOTATIONAL-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftPropositionalSentence,uSubLQuoteFn('CYCL-PROPOSITIONAL-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentence,uSubLQuoteFn('CYCL-OPEN-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonAtomicTerm,uSubLQuoteFn('CYCL-OPEN-NON-ATOMIC-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentence,uSubLQuoteFn('CYCL-OPEN-FORMULA?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftCycLOpenExpression,uSubLQuoteFn('CYCL-OPEN-EXPRESSION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftDenotationalTerm,uSubLQuoteFn('CYCL-OPEN-DENOTATIONAL-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonAtomicTermAssertible,uSubLQuoteFn('CYCL-NON-ATOMIC-TERM-ASSERTIBLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonAtomicTermAskable,uSubLQuoteFn('CYCL-NON-ATOMIC-TERM-ASKABLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonAtomicTerm,uSubLQuoteFn('CYCL-NON-ATOMIC-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftNonAtomicReifiedTerm,uSubLQuoteFn('CYCL-NON-ATOMIC-REIFIED-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftIndexedTerm,uSubLQuoteFn('CYCL-INDEXED-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftGenericRelationFormula,uSubLQuoteFn('CYCL-UNBOUND-RELATION-FORMULA-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftGAFAssertion,uSubLQuoteFn('CYCL-GAF-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftSentence,uSubLQuoteFn('CYCL-FORMULA?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftExpressionAssertible,uSubLQuoteFn('CYCL-EXPRESSION-ASSERTIBLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftExpressionAskable,uSubLQuoteFn('CYCL-EXPRESSION-ASKABLE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftCycLExpression,uSubLQuoteFn('CYCL-EXPRESSION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftDenotationalTerm,uSubLQuoteFn('CYCL-DENOTATIONAL-TERM-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftDeducedAssertion,uSubLQuoteFn('CYCL-DEDUCED-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftConstant,uSubLQuoteFn('CYCL-CONSTANT-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftClosedSentence,uSubLQuoteFn('CYCL-CLOSED-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftClosedNonAtomicTerm,uSubLQuoteFn('CYCL-CLOSED-NON-ATOMIC-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftClosedFormula,uSubLQuoteFn('CYCL-CLOSED-FORMULA?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftCycLClosedExpression,uSubLQuoteFn('CYCL-CLOSED-EXPRESSION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftClosedDenotationalTerm,uSubLQuoteFn('CYCL-CLOSED-DENOTATIONAL-TERM?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtomicTerm,uSubLQuoteFn('CYCL-CLOSED-ATOMIC-TERM-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftClosedAtomicSentence,uSubLQuoteFn('CYCL-CLOSED-ATOMIC-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtomicTerm,uSubLQuoteFn('CYCL-ATOMIC-TERM-P')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtomicSentence,uSubLQuoteFn('CYCL-ATOMIC-SENTENCE?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAtomicAssertion,uSubLQuoteFn('CYCL-ATOMIC-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAssertion,uSubLQuoteFn('CYCL-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedDefnIff(ftAssertedAssertion,uSubLQuoteFn('CYCL-ASSERTED-ASSERTION?')),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xor,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xor,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(unknownSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(trueSubL,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(trueSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(trueRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exists,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistExactly,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistExactly,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistAtMost,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistAtMost,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistAtLeast,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(thereExistAtLeast,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(termOfUnit,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(termOfUnit,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(termExternalIDString,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(skolemizeForward,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(skolem,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sharedNotes,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sharedNotes,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sentenceImplies,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sentenceImplies,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sentenceEquiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(sentenceEquiv,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(salientAssertions,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(salientAssertions,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(ruleAfterRemoving,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(ruleAfterAdding,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(relationExpansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorRuleProperties,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorRule,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorEquiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorEquiv,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorEquals,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulatorEquals,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulationPrecondition,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(reformulationDirectionInMode,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(quotedIsa,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(quotedDefnSufficient,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(quotedDefnNecessary,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(quotedDefnIff,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(querySentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(prettyString,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(pragmaticRequirement,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(pragmaticRequirement,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(pragmaticallyNormal,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(pointQuantValue,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(performSubL,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(overlappingExternalConcept,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(or,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(operatorFormulas,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(operatorFormulas,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(oldConstantName,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(oldConstantName,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(not,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(natFunction,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(natArgumentsEqual,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(natArgumentsEqual,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(natArgument,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(myCreator,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(myCreationPurpose,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(minimize,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(meetsPragmaticRequirement,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(knownSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(knownAntecedentRule,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(ist,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(irrelevantTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(irrelevantPredAssertion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(irrelevantAssertion,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(indexicalReferent,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(implies,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(implies,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(hypotheticalTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(holdsIn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(hlPrototypicalInstance,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(highlyRelevantTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(highlyRelevantPredAssertion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(highlyRelevantAssertion,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genMassNoun,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genlRules,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genlRules,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genKeyword,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genKeyword,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genFormat,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(genFormat,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(formulaArity,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(all,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(all,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(expansionDefn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(expansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exceptWhen,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exceptWhen,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exceptFor,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exceptFor,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(except,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exampleAssertions,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exampleAssertions,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(exactlyAssertedEL_next,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(evaluationDefn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(equiv,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(equiv,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(ephemeralTerm,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(defnSufficient,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(defnNecessary,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(defnIff,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(cycTransformationProofRule,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(cycProblemStoreTerms,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(cycProblemQueryTerms,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(cycProblemQuerySentence,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(constraint,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(constantName,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(constantName,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(constantGUID,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(consistent,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(collectionExpansion,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(assertionUtility,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(assertionDirection,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(arity,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(argSometimesIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(argIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(argAndRestIsa,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(and,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(afterRemoving,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(afterAdding,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(admittedSentence,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(admittedNAT,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(abnormal,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xUncanonicalizerAssertionFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xTLVariableFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xTLAssertionFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(tSetOfTheSetOfFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(tSetOfTheSetOfFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(tColOfTheCollectionOfFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(tColOfTheCollectionOfFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(uSubLQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(iSkolemFunctionFn,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(iSkolemFunctionFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(iSkolemFunctionFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(fSkolemFuncNFn,3),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(fSkolemFuncNFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(fSkolemFuncNFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xQuasiQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(prettyStringCanonical,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(iKappaFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(iKappaFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(vFormulaArityFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(tSetOfFormulaArgSetFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(vFormulaArgListFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(uFormulaArgFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(uExpandSubLFn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(uExpandSubLFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(uEvaluateSubLFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(xEscapeQuoteFn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(quotedArgument(assertionUtility_1,1),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(unitMultiplicationFactor,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(unitMultiplicationFactor,1),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(rewriteOf,1),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(pointQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(multiplicationUnits,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(multiplicationUnits,1),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(minQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(means,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(maxQuantValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(expresses,2),iUniversalVocabularyMt,vStrDef). tiny_kb(singleEntryFormatInArgs(evaluationDefn,2),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtTernaryRelation,arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtTernaryRelation,arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtScopingRelation,scopingArg),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuintaryRelation,arg5Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuintaryRelation,arg4Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuintaryRelation,arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuintaryRelation,arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuaternaryRelation,arg4Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuaternaryRelation,arg3Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtQuaternaryRelation,arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(tPred,arity),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(tPred,argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(tFunction,resultIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtFixedArityRelation,arity),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtFixedArityRelation,argIsa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtFixedArityRelation,arg1Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtEvaluatableRelation,evaluationDefn),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtCollectionDenotingFunction,resultGenl),iUniversalVocabularyMt,vStrDef). tiny_kb(requiredArg1Pred(rtBinaryRelation,arg2Isa),iUniversalVocabularyMt,vStrDef). tiny_kb(afterRemoving(skolem,uSubLQuoteFn('SKOLEM-AFTER-REMOVING')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterRemoving(relationExpansion,uSubLQuoteFn('REMOVE-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterRemoving(genKeyword,uSubLQuoteFn('REMOVE-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterRemoving(genFormat,uSubLQuoteFn('REMOVE-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterAdding(relationExpansion,uSubLQuoteFn('ADD-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterAdding(genKeyword,uSubLQuoteFn('ADD-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(afterAdding(genFormat,uSubLQuoteFn('ADD-GENERATION-ASSERTION')),iUniversalVocabularyMt,vStrDef). tiny_kb(omitArgIsa(exists,2),iUniversalVocabularyMt,vStrDef). tiny_kb(omitArgIsa(exists,1),iUniversalVocabularyMt,vStrDef). tiny_kb(omitArgIsa(all,2),iUniversalVocabularyMt,vStrDef). tiny_kb(omitArgIsa(all,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(rewriteOf,2),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(pointQuantValue,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(minQuantValue,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(maxQuantValue,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(followingValue,2),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(followingValue,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(expresses,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(evaluationDefn,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(cycTransformationProofBindings,2),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(completeExtentEnumerable,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(completeExtentDecidable,1),iUniversalVocabularyMt,vStrDef). tiny_kb(openEntryFormatInArgs(completeExtentAsserted,1),iUniversalVocabularyMt,vStrDef). tiny_kb(negationInverse(nearestGenlPreds,nearestGenlPreds),iUniversalVocabularyMt,vStrDef). tiny_kb(negationInverse(nearestGenlMt,nearestGenlMt),iUniversalVocabularyMt,vStrDef). tiny_kb(negationInverse(elInverse,elInverse),iUniversalVocabularyMt,vStrDef). tiny_kb(negationInverse(denotes,denotes),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa5_4,5),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa5_3,5),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa5_2,5),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa5_1,5),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa4_5,4),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa4_3,4),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa4_2,4),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa4_1,4),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa3_5,3),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa3_4,3),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa3_2,3),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa3_1,3),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa2_5,2),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa2_4,2),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa2_3,2),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa2_1,2),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa1_5,1),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa1_4,1),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa1_3,1),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgIsa1_2,1),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgGenl1_2,1),iUniversalVocabularyMt,vStrDef). tiny_kb(independentArg(interArgFormat1_2,1),iUniversalVocabularyMt,vStrDef). tiny_kb(hlPrototypicalInstance(rtThePrototypicalTransitiveBinaryPredicate,rtTransitiveBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(hlPrototypicalInstance(ttThePrototypicalCollection,tCol),iUniversalVocabularyMt,vStrDef). tiny_kb(hlPrototypicalInstance(rtThePrototypicalBinaryPredicate,rtBinaryPredicate),iUniversalVocabularyMt,vStrDef). tiny_kb(constrainsArg(arg2Genl,2),iUniversalVocabularyMt,vStrDef). tiny_kb(constrainsArg(arg1Genl,1),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(querySentence,pragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(querySentence,meetsPragmaticRequirement),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(exactlyAssertedEL_next,call_u_no_bc),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(uSubLQuoteFn,trueSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(uSubLQuoteFn,performSubL),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(uSubLQuoteFn,uExpandSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(conceptuallyRelated(uSubLQuoteFn,uEvaluateSubLFn),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(xor,"The LogicalConnective that represents exclusive-or in CycL. Unlike or, which is a VariableArityRelation, xor takes two arguments, which must be instances of ELSentence-Assertible. (xor P Q) means one but not both of P and Q is true. (An EL formula that mentions \n xor is translated during canonicalization into an equivalent, less compact, formula that mentions or, and, and not)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(unitMultiplicationFactor,"A ternary MetaFunction predicate that relates two interconvertible UnitOfMeasures (q.v.) to the real number by which the larger unit is a multiple of the smaller. (unitMultiplicationFactor SMALLUNIT BIGUNIT N) means that there are N SMALLUNITs in one BIGUNIT. In other words, to convert from a measure BIGUNITs to a measure in SMALLUNITs, multiply by N.\n

\nFor example, (unitMultiplicationFactor Inch Foot-UnitOfMeasure 12) entails that, when converting from feet to inches, one multiplies the number of feet by twelve.\n

\nNote that SMALLUNIT and BIGUNIT must be instances of the same InterconvertibleUnitType (q.v.), and that N must be greater than or equal to 1.\n

\nSee also QuantityConversionFn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(trueSentence,"A KBDependentRelation (q.v.) and specialization of consistent (q.v.) that is used to state that a given CycL sentence is true. (trueSentence SENT) means that SENT is true.\n

\ntrueSentence is a non-assertible predicate (see notAssertible). But this puts no real limitation on the expressive power of the Cyc system since one can assert that SENT is true by simply asserting SENT itself. \n

\nMost occurrences of the expression 'trueSentence' in CycL assertions have been added by the canonicalizer, so that certain nested sentences (or variables occurring in argument-positions intended for sentences) can receive special handling during canonicalization or inference. See the accompanying cyclistNotes for details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(transitiveViaArgInverse,"A MetaPredicate used for stating that a given predicate behaves transitively, in a specified argument-place, with respect to the inverse of a given binary predicate. (transitiveViaArgInverse PRED BINPRED N) means that the Nth argument position of PRED is \"transitive\" with respect to the inverse of BINPRED. That is, if (PRED ... ARGN ...) and (BINPRED ARGN-PRIME ARGN) hold, then so does (PRED ... ARGN-PRIME ...). For example,(transitiveViaArgInverse relationAllExists genls 2) holds; thus from (relationAllExists anatomicalParts Mammal Head-AnimalBodyPart) and (genls Horse Mammal) it follows that (relationAllExists anatomicalParts Horse Head-AnimalBodyPart). See also transitiveViaArg."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(transitiveViaArg,"A MetaPredicate used for stating that a given predicate behaves transitively, in a specified argument-place, with respect to a given binary predicate. (transitiveViaArg PRED BINPRED N) means that the Nth argument position of PRED is \"transitive\" with respect to BINPRED. That is, if (PRED ... ARG-N ...) and (BINPRED ARG-N ARG-N-PRIME) hold, then so does (PRED ... ARG-N-PRIME ...). For example, (transitiveViaArg relationAllExists genlPreds 1) holds; thus from (relationAllExists anatomicalParts Mammal Head-AnimalBodyPart) and (genlPreds anatomicalParts physicalParts) it follows that (relationAllExists physicalParts Mammal Head-AnimalBodyPart). See also transitiveViaArgInverse."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(exists,"An ExistentialQuantifier (q.v.) that corresponds to the standard existential quantifier of predicate calculus. thereExists takes as its arguments an ELVariable and an ELSentence-Assertible (such that, typically, the former occurs free in the latter). (thereExists VAR SENT) means that there is at least one thing THING such that SENT is true of it. That is, if some given CycL term that denotes THING were substituted for each free occurrence of VAR in SENT, the result would be a true sentence. For example, `(thereExists ?X (mother ?X GeorgeWBush))' means that George W. Bush has a (i.e. at least one) mother; and\n

\n(forAll ?PER\n(implies\n(isa ?PER Person)\n(thereExists ?MOM\n(mother ?MOM ?PER))))\n

\nmeans that every person has a mother. Note that some existential statements can be represented more tersely in CycL using other instances of ExistentialQuantifier, such as thereExistAtMost or thereExistExactly. Also see the cyclistNotes for thereExists."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(thereExistExactly,"An ExistentialQuantifier (q.v.) and a specialization of both thereExistAtLeast and thereExistAtMost (qq.v.). Compared to the standard existential quantifier thereExists, thereExistExactly has an extra argument-place for specifying exactly how many things satisfy a given condition (specified by an CycLSentence-Assertible, in which the also-specified CycLVariable will typically occur free). A closed sentence of the form (thereExistExactly NUM VAR SENT) means that there are exactly NUM distinct things that satisfy SENT, i.e. that render SENT true when taken as the value of VAR. For example, the sentence\n

\n

\n  (thereExistExactly 7 ?X (isa ?X Sea))\n
\n

\nmeans that there are exactly seven seas.\n

\nIn the degenerate case where VAR does not appear free in SENT, then (thereExistExactly NUM VAR SENT) is equivalent to SENT."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(thereExistAtMost,"An ExistentialQuantifier (q.v.) and a specialized (albeit higher arity) version of thereExists (q.v.). Compared to the latter, standard existential quantifier, thereExistAtLeast has an extra argument-place for specifying how many things (at the most) satisfy a given condition (specified by an ELSentence-Assertible, in which the also-specified ELVariable will typically occur free). A closed sentence of the form (thereExistAtMost NUM VAR SENT) means that there are at most NUM distinct things that satisfy SENT, i.e. that render SENT true when taken as the value of VAR. For example, the sentence\n

\n

\n  (thereExistAtMost 7 ?X (isa ?X Sea))\n
\n

\nmeans that there are at most seven seas.\n

\nIn the degenerate case where VAR does not appear free in SENT, then (thereExistAtMost NUM VAR SENT) is equivalent to SENT.\n

\nSee also thereExistAtLeast, thereExistExactly."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(thereExistAtLeast,"An ExistentialQuantifier (q.v.) and a specialized (albeit higher arity) version of thereExists (q.v.). Compared to the latter, standard existential quantifier, thereExistAtLeast has an extra argument-place for specifying how many things (at the least) satisfy a given condition (specified by an ELSentence-Assertible, in which the also-specified ELVariable will typically occur free). A closed sentence of the form (thereExistAtLeast NUM VAR SENT) means that there are at least NUM distinct things that satisfy SENT, i.e. that render SENT true when taken as the value of VAR. For example, the sentence\n

\n

\n  (thereExistAtLeast 7 ?X (isa ?X Sea))\n
\n

\nmeans that there are at least seven seas.\n

\nIn the degenerate case where VAR does not appear free in SENT, then (thereExistAtLeast NUM VAR SENT) is equivalent to SENT.\n

\nSee also thereExistAtMost, thereExistExactly."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(termOfUnit,"An InferenceRelatedBookkeepingPredicate (q.v.) that appears in system-generated assertions. termOfUnit relates unreified reifiable non-atomic terms (\"NATs\") to indexed data structures reified by the system. termOfUnit GAF (see CycLClosedAtomicSentence) assertions\nare added by the system when an unreified reifiable NAT first appears in a CycL sentence that is added to the knowledge base. When such a NAT is first used in a sentence, the Cyc system automatically creates an indexed data structure to reify the NAT. A name is automatically assigned to the new data structure by the Cyc system. (Typically, this name is character-for-character identical to the unreified reifiable NAT itself; but one should not be misled by this into thinking that termOfUnit is a specialization of equals.) The predicate termOfUnit relates the system-generated data structure to the original NAT. (termOfUnit DATA-STRUCTURE NAT) means that the data structure DATA-STRUCTURE was created to reify the value of the non-atomic term NAT, and that NAT refers to DATA-STRUCTURE, which in turn denotes something in the range of the function in the 0th (or \"arg 0\") position of NAT.\n

\nFor example, if an assertion such as (isa (RepairingFn Automobile) ProductType) introduced the unreified reifiable NAT (RepairingFn Automobile) in the Cyc knowledge base, the system would create a data structure to reify the value of (RepairingFn Automobile). The system would assign the name `(RepairingFn Automobile)' to the newly-created data structure. The system would also associate the newly-reified data structure with the unreified refiable NAT by means of the termOfUnit assertion (termOfUnit (RepairingFn Automobile) (RepairingFn Automobile)).\n

\nNote that termOfUnit assertions are made in the BaseKB because the relation between a NAT and the data structure reified for it is meant to hold in all contexts. \n

\nOne should view termOfUnit assertions as bits of bookkeeping knowledge that are very rarely, if ever, entered into the Cyc knowledge base by hand. See retainTerm -- the predicate to use to create a NART that one wishes to remain in the Cyc KB even if no substantive additional assertions are made about it. NARTs that have only termOfUnit assertions made about them are removed from the KB at build time."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(termDependsOn,"(termDependsOn DEP-TERM INDEP-TERM) states that the reason for the existence of the term DEP-TERM in the Cyc knowledge base is completely dependent on the continued existence of the term INDEP-TERM. Thus, if INDEP-TERM should ever be removed from the knowledge base, then DEP-TERM should also be immediately removed. This relationship is automatically maintained between reified non-atomic terms (NATs) and the terms from which they are constructed."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(subsetOf,"This predicate relates a set or collection SUB to a set or collection SUPER whenever the extent (see extent) of SUB is a subset of the extent of SUPER. That is, (subsetOf SUB SUPER) means that every element of (see elementOf) SUB is an element of SUPER. subsetOf is thus a generalization both of the subset relation in set theory and of genls (q.v.); and (unlike either of those other relations) subsetOf can hold between a set and a collection, or between a collection and a set."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(skolemizeForward,"(skolemizeForward FUNC) tells the inference engine that terms should be generated for fully-bound uses of FUNC during forward inference."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(skolem,"An InferenceRelatedBookkeepingPredicate (q.v.) that appears in system-generated assertions. skolem holds of all instances of SkolemFunction, and exists solely for internal bookkeeping purposes. The set of supports for a skolem assertion of the form (skolem FUNCTOR) is the set of defining assertions of FUNCTOR."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(singleEntryFormatInArgs,"An instance of SpecificEntryFormatPredicate (q.v.). (singleEntryFormatInArgs PRED N) means that, for any particular way of fixing the other arguments to PRED besides the Nth, there is at most one thing such that, if taken as the Nth argument, PRED holds of those arguments. That is, if the sequences <... ARGN ...> and <... ARGN-PRIME ...> differ at most in their Nth items and both (PRED ... ARGN ...) and (PRED ... ARGN-PRIME ...) hold, then ARGN = ARGN-PRIME (see equals). For example, singleEntryFormatInArgs holds of biologicalMother with respect to its second argument-place, since an animal can only have one biological mother. A predicate with a single-entry format argument-place is thus a StrictlyFunctionalPredicate (q.v.) that is \"functional\" with respect to that argument-place (see strictlyFunctionalInArgs). Contrast with openEntryFormatInArgs."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(siblingDisjointExceptions,"A predicate that is used to make exceptions to constraints normally imposed by some instance of SiblingDisjointCollectionType or SiblingDisjointSetOrCollectionType (qq.v.). (siblingDisjointExceptions SETORCOL1 SETORCOL2) means that the pair consisting of SETORCOL1 and SETORCOL2 is exempt from the disjointness constraint that would otherwise be imposed because those set-or-collections are both elements of some instance of SiblingDisjointCollectionType or SiblingDisjointSetOrCollectionType. (See these collections' comments for a full explanation of the constraints.) \n

\nFor example, SensoryNerve and CranialNerve are both instances of OrganismPartType, which in turn is an instance of SiblingDisjointCollectionType. Consequently, since SensoryNerve is not a specialization of CranialNerve (or vice versa), the two collections have a default disjointness constraint placed between them. However, such a disjointness constraint should be blocked, since any instance of OpticNerve is an instance of both SensoryNerve and CranialNerve. By asserting (siblingDisjointExceptions SensoryNerve CranialNerve), we block the disjointness constraint between those two collections, without disturbing the constraints between each of those collections and all their other (sibling) instances of the parent collection OrganismPartType."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(sharedNotes,"A predicate-denoting constant that is an instance of DocumentationPredicate. It is sometimes useful to include the same piece of text in the documentation of two or more constants or other CycLIndexedTerms. Rather than actually duplicating text in the Knowledge Base, one can create a SharedNote (q.v.): a piece of text that is to serve as this shared documentation, and which is itself the comment (see comment) on the SharedNote's constant. (Thus the constants for shared-notes actually denote their own comments.) (sharedNotes TERM NOTE) means that NOTE is a string of text (see TextString) serving as shared documentation partly about TERM. Since SharedNotes are typically _shared_, there are likely to be one or more other indexed terms having NOTE as their shared-note as well."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(sentenceEquiv,"(sentenceEquiv FORMULA-1 FORMULA-2) means that the ELSentence-Assertible FORMULA-1 is logically equivalent to the ELSentence-Assertible FORMULA-2. This predicate is very similar to equiv, but equiv is an instance of LogicalConnective, while sentenceEquiv is an instance of Predicate. sentenceEquiv is primarily intended to be used for rules that quantify over CycL formulas."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(sentenceDesignationArgnum,"Used to specify which argument of a given MicrotheoryDesignatingRelation\ndesignates the CycL sentence to be interpreted in a specific microtheory."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(scopingArg,"A binary MetaRelation that relates a ScopingRelation (q.v.) to an integer indicating the argument-place of the former that takes a variable or list of variables. (scopingArg RELN N) means that RELN's Nth argument is a variable or variable-list (see CycLVariable and CycLVariableList) such that it (they) and any other occurrences of the same variable(s) that occur free in the CycL formula serving as the \"scoped\" argument (see scopedFormulaArg) to RELN is (are) bound with respect to the entire RELN-based formula. For example, (scopingArg thereExists 1) entails that in the sentence\n

\n

\n  (thereExists ?KIT\n    (and\n      (isa ?KIT Cat)\n      (isa ?KIT BlackColor)))\n
\n

\neach occurrence of the variable '?KIT' is bound by the quantifier thereExists."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(salientAssertions,"(salientAssertions TERM ASSERTION) means that ASSERTION has been deemed one of the assertions most useful to examine when one is trying to figure out the intended meaning of TERM. Thus, ASSERTION will normally contain TERM, and should be something that has been asserted on its own in the KB as well. Statements using salientAssertions are primarily intended for human consumption, and are not normally used by the Cyc inference engine."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rewriteOf,"A specialization of equals and a CycLReformulatorConstant that relates pairs of CycLClosedDenotationalTerms. rewriteOf is, in a sense, a \"directional\" version of equals. (rewriteOf FAVORED-TERM DISFAVORED-TERM) means that (1) FAVORED-TERM and DISFAVORED-TERM denote the same thing, and (2) FAVORED-TERM is deemed worthy of being privileged over DISFAVORED-TERM in the following senses: assertions made on DISFAVORED-TERM will be propagated to FAVORED-TERM, and whenever possible attempts to reason about DISFAVORED-TERM will be transformed into attempts to reason about FAVORED-TERM. The propagated assertions will differ from the original assertions only in that the propagated assertions will be the result of substituting FAVORED-TERM for DISFAVORED-TERM wherever DISFAVORED-TERM occurs in the original assertions. Note that substitution does not happen in the opposite direction. That is, assertions containing FAVORED-TERM will not propagate to DISFAVORED-TERM.\n

\nOne common use of rewriteOf is that in which FAVORED-TERM is a syntactically simpler term than DISFAVORED-TERM. For example, FAVORED-TERM may contain fewer nested terms that denote Function-Denotationals than does DISFAVORED-TERM. (rewriteOf UnitedStatesNavy (NavyFn UnitedStatesOfAmerica)) is a good example of this common sort of use.\n

\nNote that rewriteOf expresses a strictly conventional notion of \"directional\" equality. Pragmatic considerations, not ontology, will dictate which term is chosen to occur as the privileged (left-hand side) term in a rewriteOf assertion. Thus, in the example the fact that simpler terms are generally easier to use (remember, manipulate, etc.) dictates that UnitedStatesNavy should be a rewrite of (NavyFn UnitedStatesOfAmerica), and not vice versa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(resultIsaArg,"A MetaRelation predicate. (resultIsaArg FUNC N) means that the value returned by FUNC for any given sequence of arguments is an instance of the Nth argument in that sequence. That is, if (FUNC ARG1 ... ARGN ...) = VALUE, then (isa VALUE ARGN) holds. Obviously, ARGN must be a collection; so FUNC's Nth argument-place is likely to be constrained (via argIsa) to be an instance of Collection or some specialization thereof.\n

\nFor example, (resultIsaArg The 1) entails that (The Dog) is an instance of Dog.\n

\nSee also resultGenlArg and resultIsa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(resultIsa,"A binary MetaFunction that is used to indicate that any value returned by a given function (see Function-Denotational) is an instance of a given collection. (resultIsa FUNC COL) means that FUNC returns an instance of COL for any sequence of arguments for which FUNC is defined. That is, (isa (FUNC . ARGS) COL) holds for any sequence ARGS for which FUNC has a value (see valueOfFunctionForArgs and relationDomain). \n

\nFor example, (resultIsa PlusFn ScalarInterval) holds, and it entails (e.g.) (isa (PlusFn 2 2) ScalarInterval). \n

\nSee also resultGenl."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(resultGenlArg,"A MetaFunction predicate that holds of certain CollectionRelatingFunctions with respect to certain argument-places. (resultGenlArg FUNC N) means that FUNC always returns a subcollection of its own corresponding Nth-place argument, and that FUNC is \"genls preserving\" in that argument-place. More precisely: (i) the value of FUNC for any sequence of arguments for which it is defined is a subcollection of the Nth item in that sequence (i.e. (genls (FUNC ARG1..ARGN..) ARGN)) and (ii) (preservesGenlsInArg FUNC N) holds. For example, (resultGenlArg JuvenileFn 1) entails (genls (JuvenileFn Dog) Dog) and -- given that (genls Dog Mammal) -- (genls (JuvenileFn Dog) (JuvenileFn Mammal)). See also resultIsaArg and resultGenl."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(resultGenl,"A MetaFunction that is used to specify that a \ngiven collection is a supercollection of any value returned by a given CollectionDenotingFunction (q.v.). (resultGenl COLFUNC COL) means that when COLFUNC is applied to any sequence of arguments ARGS for which it is defined, the resulting value will be a subcollection of COL. That is, (genls (COLFUNC . ARGS) COL) holds. \n

\nFor example, (resultGenl UsingAFn Action) implies that the collection of acts done using any given type of object is a type of action, (resultGenl AttemptingFn PurposefulAction) implies that the attempts at a given type of action constitute a type of purposeful act, and (resultGenl JointTypeBetweenFn Joint-Physical) means that the collection of joints between two given types of things is a type of physical joint. \n

\nSee also resultIsa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(requiredArg3Pred,"A MetaPredicate for stating that every instance of a given collection is related (as the \"arg3\") to some things by a given predicate. (requiredArg3Pred COL PRED) means that for every instance INST of COL, there exists some sequence <X1, X2,..., Xn> such that (PRED X1 X2 INST ... Xn) holds. For example, (requiredArg3Pred ConflictEvent opponentsInConflict) means that every conflict involves (at least) two opponents. See also requiredArg1Pred and requiredArg2Pred."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(requiredArg2Pred,"A MetaPredicate for stating that every instance of a given collection is related (as the \"arg2\") to some thing or things by a given predicate. (requiredArg2Pred COL PRED) means that for every instance INST of COL, there exists some sequence of such that (PRED X1 INST X3 ... Xn) holds. For example, (requiredArg2Pred Side objectSides) means that every side is the side of at least one object. See also requiredArg1Pred."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(requiredArg1Pred,"A MetaPredicate for stating that every instance of a given collection is related to some thing or things by a given predicate. (requiredArg1Pred COL PRED) means that for every instance INST of COL, there exists some sequence ARGS such that (PRED INST . ARGS) holds. For example, (requiredArg1Pred Organization hasMembers) means that every organization has at least one member. \n

\nSee also requiredArg2Pred and requiredArg3Pred."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationInstanceAll,"A ternary RuleMacroPredicate that is used to state that a given binary predicate holds between a given thing and all instances of a given collection. (relationInstanceAll BINPRED THING COL) means that THING bears the relation PRED to every instance INST of COL such that (BINPRED THING INST) holds. It is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n(implies\n(isa ?INST COL)\n(BINPRED THING ?INST)) .\n

\nFor example, `(relationInstanceAll geopoliticalSubdivision UnitedStatesOfAmerica State-UnitedStates)' means that each State in the Union is a subdivision of the United States. Cf. relationAllInstance, and see NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExpansion,"ARG2 is a CycL expression which indicates the meaning of expressions in which the relation ARG1 is the operator (i.e., in which ARG1 is in the 0th argument position). In ARG2, the variables ?arg1, ?arg2, ?arg3, ?arg4, and ?arg5 correspond to the objects in the argument positions 1, 2, 3, 4, and 5, respectively, in expressions which have ARG1 as the operator."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExistsMinAll,"A quaternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate stands in a certain numerical relation with respect to two collections. (relationExistsMinAll BINPRED COL1 COL2 N) means that for any instance INST of COL2, there are at least N instances of (INST(1), ..., INST(N)) of COL1 such that (BINPRED INST(i) INST) holds (for 1 <= i <= N). This is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n(implies\n(isa INST COL2)\n(thereExistAtLeast N ?INST-I\n(and\n(isa ?INST-I COL1)\n(BINPRED ?INST-I INST)))) .\n

\nFor example, `(relationExistsMinAll physicalParts Hand Finger 1)' means that every finger is part of at least one hand. Cf. relationAllExistsMin, and see the shared NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExistsMaxAll,"A quaternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate stands in a certain numerical relation with respect to two collections. (relationExistsMaxAll BINPRED COL1 COL2 N) means that for any instance INST of COL2, there are at most N instances of (INST(1), ..., INST(N)) of COL1 such that (BINPRED INST(i) INST) holds (for 1 <= i <= N). This is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n  (implies\n    (isa INST COL2)\n    (thereExistAtMost N ?INST-I\n      (and\n        (isa ?INST-I COL1)\n        (BINPRED ?INST-I INST)))).\n
\nFor example, (relationExistsMaxAll physicalParts Hand Finger 1) means that every finger is part of at most one hand. Cf. relationAllExistsMax, and see the shared NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExistsInstance,"A ternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate holds between some instance of a given collection and a given thing. (relationExistsInstance BINPRED COL THING) means that there exists an instance INST of COL such that (BINPRED INST THING) holds. This is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n

\n(thereExists ?INST\n  (and\n     (isa ?INST COL)\n     (PRED ?INST THING))) .\n
\n

\nFor example, (relationExistsInstance eventOccursAt IllegalDrugActivity Sweden) means that there exists illegal drug activity in Sweden. See also the shared NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExistsCountAll,"A quaternary RuleMacroPredicate (q.v.) that is used to state that a given binary predicate stands in a certain numerical relationship with respect to two collections. (relationExistsCountAll BINPRED COL1 COL2 N) means that for every instance INST of COL2 there are exactly N instances of COL1 (INST(1), ..., INST(N)) such that (BINPRED INST(i) INST) holds (for 1 <= i <= N). It is equivalent to (and so can be used in effect as shorthand for) the more complex form:\n

\n

\n  (implies\n    (isa ?INST COL2)\n    (thereExistExactly N ?INST-I\n      (and\n             (isa ?INST COL1)\n             (BINPRED ?INST-I ?INST)))) .\n
\n

\nFor example, (relationExistsCountAll anatomicalParts Animal Head-AnimalBodyPart 1) means that every animal head is a part of exactly one animal. See also relationAllExistsCount and NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationExistsAll,"A ternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate stands in a certain relation to two collections. (relationExistsAll BINPRED COL1 COL2) means that for any instance INST2 of COL2, there exists some instance INST1 of COL1 such that (BINPRED INST1 INST2) holds. It is equivalent to (and can thus be used in effect as shorthand for) the more complex form\n

\n  (implies\n    (isa ?INST2 COL2)\n    (thereExists ?INST1\n      (and\n        (isa ?INST1 COL1)\n        (BINPRED ?INST1 ?INST2)))).\n
\nFor example, (relationExistsAll adjacentTo Harbor PortCity) means that for every port city there exists a harbor to which the city is adjacent. See also relationAllExists and NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationAllExistsMin,"A quaternary RuleMacroPredicate that can be used to state that a given binary predicate stands in a certain numerical relationship with respect to two collections. (relationAllExistsMin BINPRED COL1 COL2 N) means that for any instance INST of COL1 there are at least N instances (INST(1), ..., INST(N)) of COL2 such that (BINPRED INST INST(i)) holds (for 1 <= i <= N). This is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n(implies\n(isa ?INST COL1)\n(thereExistAtLeast N ?INST-I\n(and\n(isa ?INST-I COL2)\n(BINPRED ?INST ?INST-I)))) .\n

\nFor example, `(relationAllExistsMin subEvents EatingEvent Swallowing 1)' means that every act of eating includes at least one swallowing. Cf. relationExistsMinAll, and see NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationAllExistsMax,"A quaternary RuleMacroPredicate that can be used to state that a given binary predicate stands in a certain numerical relationship with respect to two collections. (relationAllExistsMax BINPRED COL1 COL2 N) means that for any instance INST of COL1 there are at most N instances (INST(1), ..., INST(N)) of COL2 such that (BINPRED INST INST(i)) holds (for 1 <= i <= N). This is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n(implies\n(isa ?INST COL1)\n(thereExistAtMost N ?INST-I\n(and\n(isa ?INST-I COL2)\n(BINPRED ?INST INST-I)))) .\n

\nFor example, `(relationAllExistsMax anatomicalParts Dog Leg 4)' means that all dogs have at most four legs.\n

\nCf. relationExistsMaxAll; also see NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationAllExistsCount,"A quaternary RuleMacroPredicate that is a specialization of both relationAllExistsMin and relationAllExistsMax (qq.v.). (relationAllExistsCount BINPRED COL1 COL2 N) means that for any instance INST of COL1 there are exactly N instances INST1, ..., INSTn of COL2 such that (BINPRED INST INSTi) holds (for 1 <= i <= N). It is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n  (implies\n    (isa ?INST COL1)\n    (thereExistExactly N ?INST-I\n      (and\n        (isa ?INST-I COL2)\n        (BINPRED ?INST ?INST-I))))\n
\n

\n(wherein the variable ?INST is interpreted as if it were bound by an initial universal quantifier).\n

\nFor example, (relationAllExistsCount anatomicalParts Dog Leg 4) means that all dogs have four legs.\n

\nCf. relationExistsCountAll, and see the NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(relationAllExists,"A ternary RuleMacroPredicate (q.v.) that can be used to state that a given binary predicate stands in a certain relation to two collections. (relationAllExists BINPRED COL1 COL2) means that for any instance INST1 of COL1, there exists some instance INST2 of COL2 such that (BINPRED INST1 INST2) holds. It is equivalent to (and can thus be used in effect as shorthand for) the more complex form:\n

\n

\n  (implies\n    (isa ?INST1 COL1)\n    (thereExists ?INST2\n      (and\n        (isa ?INST2 COL2)\n        (BINPRED ?INST1 ?INST2)))).\n
\n

\nFor example, (relationAllExists temporalBoundsContain CalendarWeek Wednesday) means that every calendar week contains a Wednesday. See also relationExistsAll and NoteAboutUseOfRuleMacroPredicates."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(quotedIsa,"A binary MetaLanguagePredicate (q.v.) that relates CycL expressions to the SubLExpressionTypes (q.v.) of which they are instances. quotedIsa is thus like a restricted version of isa (q.v.), but with one important difference: the first argument-place of quotedIsa is \"implicitly quoted\" (see quotedArgument). So a ground atomic sentence of the form (quotedIsa THING EXPR-TYPE) does not mean that THING itself is an instance of EXPR-TYPE. Rather, such a sentence is partly self-referential, and means that the particular CycL expression appearing in the sentence's own first argument-position is an instance of EXPR-TYPE. Thus, quotedIsa provides a convenient shorthand for stating certain things that would otherwise require explicit quotation (or some other device for naming expressions).\n

\nThis is better illustrated with a specific example. Suppose we wish to state that the CycL constant IndianOcean is an instance of the CycL expression type PublicConstant. We cannot express this with the straightforward isa sentence (isa IndianOcean PublicConstant), as that states the falsehood that the IndianOcean itself -- which is not a constant but a body of water -- is a public constant. But we can express precisely what we want like this:\n

\n  (quotedIsa IndianOcean PublicConstant) .\n
\nNow quotedIsa is a MacroRelation (q.v.), and by its expansion any given quotedIsa sentence is equivalent to some isa sentence with an explicitly quoted first argument. The sentence displayed above turns out to be equivalent to: \n
\n  (isa (Quote IndianOcean) PublicConstant).\n
\nBut the quotedIsa version has two related practical advantages over the isa version. First, the former is syntactically simpler than the latter. Second, the simpler syntax of the former makes it easier to browse in the Knowedge Base: while the quotedIsa version is conveniently indexed under the KB Browser page for the constant IndianOcean, the isa version would apparently be indexed under a separate, brand new page for the term (Quote IndianOcean). Generalizing the point, quotedIsa lets us avoid having potentially to double the number of pages currently in the browser.\n

\nFor the semantically more complicated (but rarely encountered) case in which quotedIsa's first argument-place is filled with an open expression, see the accompanying cyclistNotes."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(quotedArgument,"The main (longer) comment on this predicate was written to explain the role of quotedArgument in an earlier approach for referring to CycL expressions in the CycL language that is currently (April 2002) being phased out in favor of a new approach. Whereas the earlier approach enabled self-reference only by means of a sort of \"implicit quotation\", the new approach involves a mechanism for explicitly quoting CycL expressions (by putting them inside something analogous to quotation marks). quotedArgument, unlike quotedCollection (q.v.), still has a role to play with respect to the new approach, and its main comment will soon revised to better explain that role. For an explanation of the new approach to quoting, see the shared NoteAboutQuotingInCycL and the constants that share that note."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(quotedArgument,"A specialization of opaqueArgument (q.v.). quotedArgument is a binary MetaLanguagePredicate used to state that a given argument-place of a given CycL relation-denoting expression is an implicitly quoted context, in the sense that a symbol appearing in that context denotes itself (as opposed to whatever that symbol might denote, if anything, in ordinary non-quoted contexts). \n

\n(quotedArgument REL N) means that in a closed compound expression built from REL -- i.e. a ground atomic sentence (or gaf) if REL is a predicate or a closed non-atomic term (or nat) if REL is a function -- the term (i.e. the CycL expression) EXPR appearing in REL's Nth argument-place is taken to denote itself (i.e. that very expression EXPR). \n

\nquotedArgument thus makes possible a kind of a self-reference in CycL. Relations with quoted argument-places can be used to make statements about particular CycL expressions, without quoting those expressions explicitly (cf. Quote).\n

\nFor example, the first argument-place of the predicate myCreator is quoted and its second argument-place is not. Thus in the sentence (myCreator PlanetEarth Maeda), the CycL constant PlanetEarth denotes that constant itself (and not the actual planet Earth), while the constant Maeda simply denotes the person Maeda (and not a CycL expression). Hence the above sentence correctly states that Maeda created (i.e. reified) the CycL constant PlanetEarth; it does not state the absurdity that he created the planet Earth. In ordinary non-quoted contexts, of course, PlanetEarth denotes the planet and not the constant.\n

\nSee also quotedCollection and NoteAboutUseVersusMention."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(quantityIntersects,"A binary predicate that relates numerically measurable ScalarIntervals (q.v.) that intersect or overlap. (quantityIntersects SCALAR1 SCALAR2) means that SCALAR1 and SCALAR2 intersect. More precisely: there is some scalar interval (which might even be as small as an instance of ScalarPointValue) that is subsumed by (see quantitySubsumes) both SCALAR1 and SCALAR2.\n

\nFor example, (Meter 2 5) -- the Distance of between 2 and 5 meters inclusive -- intersects both (Meter 3 4) and (Meter 3 7), but does not intersect (Meter 6 7)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(prettyString,"(prettyString TERM STRING) means that STRING is the English word or expression (sequence of words) commonly used to refer to TERM. The predicate prettyString is used by the code which generates CycL to English paraphrases, but its applicability is not restricted to this use."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(preservesGenlsInArg,"(preservesGenlsInArg FUNCTION N) means that the CollectionDenotingFunction FUNCTION has the following properties: \n

\n(1) argument place N of FUNCTION is constrained to instances of Collection, and
\n(2) if COLLECTION1 and COLLECTION2 can both serve as the Nth argument of FUNCTION, and COLLECTION2 is a specialization of COLLECTION1 (so that (genls COLLECTION2 COLLECTION1) holds), then (genls (FUNCTION ARG_1 ARG_2 ... ARG_N-1 COLLECTION2 ... ARG-M) (FUNCTION ARG_1 ARG_2 .. ARG_N-1 COLLECTION1 ... ARG-M)) also holds, where ARG_1, ARG_2, ..., ARG_M (where M is the arity of FUNCTION) are admitted arguments for FUNCTION (see admittedArgument). \n

\nFor example, (preservesGenlsInArg GroupFn 1) holds because (genls COL-2 COL-1) implies (genls (GroupFn COL-2) (GroupFn COL-1)), for all collections COL-1 and COL-2 that satisfy the argument constraints for GroupFn. \n

\nSimilarly, (preservesGenlsInArg SubcollectionOfByTypeFn 2) holds because (genls COL-2 COL-1) implies (genls (SubcollectionOfByTypeFn FIXED-ARG COL-2) (SubcollectionOfByTypeFn FIXED-ARG COL-1)) for all collections COL-1 and COL-2, and all arguments FIXED-ARG, that satisfy the appropriate argument constraints for SubcollectionOfByTypeFn. See also the collection GenlsPreservingFunction."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(pragmaticallyNormal,"A MetaKnowledgePredicate that is used to express that certain pragmatic preconditions on a given rule are satisfied. The predicate takes as arguments a list of CycL variables and an asserted rule (see CycLRuleAssertion) in which those variables occur \"free\". At the EL (\"epistemological level\"), pragmaticallyNormal sentences are not asserted as GAFs, but appear instead as the antecedents of system-generated implies rules. For a given sequence of values for the respective variables VAR1, ..., VARn, (pragmaticallyNormal (TheList VAR1 ... VARn) RULE) means that any pragmatic preconditions placed on RULE's being used by the Cyc inference engine (see pragmaticRequirement) are satisfied with respect to those values.\n

\nLet's make this more precise and explicit. A pragmatic precondition for a rule is written like so:\n

\n(pragmaticRequirement CONDITION RULE)\n

\nand gets canonicalized into a rule involving pragmaticallyNormal like so:\n

\n(implies\n(pragmaticallyNormal (TheList VAR1 ... VARn) RULE)\nCONDITION),\n

\nwhere VAR1, ..., VARn are all and only the variables that occur free in RULE and thus include all (and possibly only) the variables that occur free in CONDITION (i.e. as RULE and CONDITION explicitly appear in the KB browser, without consideration of their having \"implicit\" initial universal quantifiers).\n

\nThe above pragmaticallyNormal rule is used in inference as though it were a constraint rule. If CONDITION does not hold for a given sequence of values for its variables , then those values are not \"pragmatically normal\" for RULE; and hence inference will not proceed using with RULE.\n

\nThe effect of the foregoing is that any asserted rule RULE is implicitly treated by the Cyc inference engine as if it had the form\n

\n(implies\n(pragmaticallyNormal (TheList VAR1 ... VARn) RULE)\nRULE)\n

\n(with VAR1, ..., VARn as described above).\n

\nThis convention allows the logical content of a rule to be expressed independently of any pragmatic preconditions for its being used in inference.\n

\nAlso see abnormal, which is syntactically similar and has a related interpretation that makes it roughly the complement of pragmaticallyNormal."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(pointQuantValue,"A NumericComparisonPredicate and a specialization of numericallyEquals, minQuantValue, and maxQuantValue (qq.v.). pointQuantValue is essentially the relation numericallyEquals restricted to scalar point-values, with the additional proviso that its first argument must be given using a reifiable CycL term. Thus a sentence of the form\n

\n\t(pointQuantValue REIFIABLE-TERM OTHER-TERM)\n

\nis true if and only if REIFIABLE-TERM is a CycLReifiableDenotationalTerm (q.v.), and REIFIABLE-TERM and OTHER-TERM denote the same ScalarPointValue (q.v.).\n

\nThis predicate is primarily used to state the equivalence of a reified scalar-denoting term (e.g. 'Zero', 'AvogadrosNumber', 'SpeedOfLight') with an appropriate unreifiable term. For example, both of the following sentences hold:\n

\n

\n  (pointQuantValue Zero 0)\n
\n

\n

\n  (pointQuantValue\n    SpeedOfLight\n    (PerFn (Mile 186000) (HoursDuration 1))'  .\n
"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(or,"A LogicalConnective that represents disjunction in CycL. It is a VariableArityRelation, taking an arbitrary number of instances of CycLSentence-Assertible as arguments. (or P Q ... Z) is true if and only if at least one of the sentences P, Q, ..., or Z is true."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(openEntryFormatInArgs,"An instance of SpecificEntryFormatPredicate (q.v.). (openEntryFormatInArgs PRED N) means that, for any particular way of fixing the other arguments to PRED besides the Nth, there might be any number (including zero) of things such that, if taken as the Nth argument, PRED holds of those arguments. For example, openEntryFormatInArgs holds of biologicalMother with respect to its first argument-place, since a given female animal might have any number of offspring. \n

\nUnlike the other reified instances of SpecificEntryFormatPredicate, openEntryFormatInArgs actually places no restriction at all on what PRED might or might not hold of with respect to the specified argument-place. But one should not infer from this that openEntryFormatInArgs assertions are pointless; for they forestall duplication of effort by serving notice that the entry-format of a given argument-place has previously been considered and openEntryFormatInArgs was deemed appropriate. \n

\nopenEntryFormatInArgs is the most commonly-encountered specific entry-format in the Cyc Knowledge Base. Contrast with singleEntryFormatInArgs."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(opaqueArgument,"A binary MetaLanguagePredicate that can be used to state that a given argument-place of a given CycL relation-denoting expression is denotationally opaque. \n

\n(opaqueArgument REL N) means that if in a closed compound expression built from the CycL expression for REL -- i.e. a ground atomic formula (or gaf) if REL is a predicate or a closed non-atomic term (or nat) if REL is a function -- the term appearing in REL's Nth argument-place is replaced with another term having the same denotatum (or truth-value, if the term is a sentence), there is no guarantee that the resulting gaf (or nat) will itself have the same truth-value (or denotatum) as the original. \n

\nMost argument-places of most relation-denoting expressions do allow such substitutions to be made freely, and are thus denotationally transparent. For example, given that (equals Cicero Tully), the truth of (residesInRegion Cicero CityOfRomeItaly) entails the truth of (residesInRegion Tully CityOfRomeItaly). This shows that residesInRegion's first argument-place is denotationally transparent. On the other hand, if Caesar were seeking Cicero and found him then (objectFound-Definite CaesarsSearchForCicero Caesar Cicero) would be true; but (objectFound-Definite CaesarsSearchForCicero Caesar Tully) might nevertheless be false, because Caesar might not know that Tully is Cicero and thus might not realize that in finding Cicero he had found Tully. Having such a realization is a necessary condition for objectFound-Definite's holding, which shows that this relation's third argument-place is denotationally opaque. \n

\nAccording to one well-known semantics for denotational opacity (viz. GottlobFrege's), a term appearing in an opaque context (in most cases) denotes (not its ordinary denotatum, but) what is ordinarily its intensional meaning or sense (or Sinn, in Frege's native German). \n

\nquotedArgument (q.v.) is a specialization of opaqueArgument, and a term appearing in a quoted context is interpreted as denoting itself (rather than its usual denotatum)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(numericallyEquals,"A NumericComparisonPredicate that is applicable to ScalarIntervals (q.v.) of all sorts, including quantitative intervals (see NumericInterval and Quantity) as well as point values (see ScalarPointValue). (numericallyEquals VALUE1 VALUE2) means that VALUE1 is equal to VALUE2 with respect to some scale that they are both on. More precisely, there is some TotallyOrderedScalarIntervalType SCALE that VALUE1 and VALUE2 are instances of and the minimum (see minQuantValue) of VALUE1 is equal to the minimum of VALUE2 and the maximum (see maxQuantValue) of VALUE1 is equal to the maximum of VALUE2.\n

\nNote that numericallyEquals is not a specialization of equals (q.v.), as numeric values of different sorts can be \"numerically equivalent\" without being considered identical (e.g. the Integer 1 and the RealNumber 1.0)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(not,"An instance of both LogicalConnective and UnaryRelation. which takes an instance of #CycLSentence-Assertible as its argument. (not SENT) is true if and only if SENT is false (and false if and only if SENT is true)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(negationPreds,"A MetaPredicate for stating that two predicates are logical \"contraries\" of one another. (negationPreds PRED1 PRED2) means that if PRED1 holds among a given sequence of things, then PRED2 does not hold among that sequence (and vice versa). Thus it is equivalent to \n\n

  (not (and (PRED1 . ARGS) (PRED2 . ARGS))) .
\n\nFor example, (negationPreds owns rents) holds, as one cannot both own and rent a given thing at the same time. \n

\nNote that the argument types of PRED1 and PRED2 need not be the same, they merely must not be disjoint. Note also that PRED1 and PRED2 are constrained (see e.g. interArgIsa) either to both having the same fixed-arity (see FixedArityRelation) or to both having variable-arity (see VariableArityRelations). \n

\nSee also genlPreds and negationInverse."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(negationMt,"(negationMt MT-1 MT-2) means that the domain assumptions of the Microtheory MT-1 are inconsistent with those of the Microtheory MT-2, and no lifting can occur between MT-1 and MT-2 (i.e. assertions made in one microtheory should not be made visible to the other microtheory). For cases where two microtheories differ not in domain assumptions but purely in content (assertions made within those microtheories), see the less specialized contradictoryMt."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(negationInverse,"A MetaPredicate for stating that each of two binary predicates is a logical \"contrary\" of the other's inverse. (negationInverse BINPRED1 BINPRED2) means that if BINPRED1 holds between a pair , then BINPRED2 does not hold between the inverse pair (and vice versa). In other words, (negationInverse BINPRED1 BINPRED2) is equivalent to (not (and (BINPRED1 ARG1 ARG2) (BINPRED2 ARG2 ARG1))).\n

\nNote that any AsymmetricBinaryPredicate is related to itself by negationInverse. For example, (negationInverse subordinates subordinates) holds, since if one person is a subordinate of another, the latter person cannot at the same time also be a subordinate of the former. See also negationPreds and genlInverse."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(nearestGenlPreds,"A TaxonomicSlotForPredicates and a specialization of genlPreds (q.v.). (nearestGenlPreds PRED NEAR-PRED) means that NEAR-PRED is a \"nearest\" generalization of PRED. That is, (genlPreds PRED NEAR-PRED) holds, PRED is not identical to NEAR-PRED, and there is no reified Predicate OTHER-PRED distinct from PRED and NEAR-PRED such that both (genlPreds PRED OTHER-PRED) and (genlPreds OTHER-PRED NEAR-PRED) hold. Note that nearestGenlPreds is non-assertible (see notAssertible), since its extension at any given time depends upon (and so must be recomputed from) the current state of the genlPreds hierarchy in the Cyc Knowledge Base."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(nearestGenlMt,"A specialization of genlMt. (nearestGenlMt MT NEAR-MT) means that NEAR-MT is a \"nearest\" microtheory of which MT is a specialization. That is, (genlMt MT NEAR-MT) holds, MT is not identical to NEAR-MT, and there is no reified Microtheory NEARER-MT distinct from MT and NEAR-MT such that both (genlMt MT NEARER-MT) and (genlMt NEARER-MT NEAR-MT) hold. Note that nearestGenlMt is non-assertible (see notAssertible), since its extension at any given time depends upon (and so must be recomputed from) the current state of the genlMt hierarchy in the Cyc Knowledge Base."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(nearestCommonGenlMt,"(nearestCommonGenlMt MT-1 MT-2 NEAR-MT) relates microtheories MT-1 and MT-2 to the nearest unsubsumed microtheories NEAR-MT of which both are spec microtheories. This predicate is notAssertible, since it must always be recomputed from the current state of the genlMt hierarchy."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(multiplicationUnits,"A ternary predicate that relates UnitOfMeasure (q.v.) functions. (multiplicationUnits UNIT1 UNIT2 PRODUNIT) means that PRODUNIT is the unit-of-measure that always returns the product of the values returned by UNIT1 and UNIT2 for two respective arguments (or argument-sequences) when it is itself applied to the product of those arguments (or sequences). That is, whenever (UNIT1 . ARGS1) = VALUE1 and (UNIT2 . ARGS2) = VALUE2, then (PRODUNIT (TimesFn ARGS1 ARGS2)) = (TimesFn VALUE1 VALUE2).\n

\nFor example, (multiplicationUnits Mile Mile SquareMile) holds, and thus (TimesFn (Mile 2) (Mile 3)) is equal to (SquareMile 6).\n

\nThe predicate multiplicationUnits corresponds to (see functionCorrespondingPredicate) both of the functions UnitProductFn and PerFn (qq.v.). Thus,\n

\n\t(multiplicationUnits UNIT1 UNIT2 PRODUNIT)\n

\nis equivalent to\n

\n\t(equals PRODUNIT (UnitProductFn UNIT1 UNIT2))\n

\nis equivalent to\n

\n\t(equals UNIT1 (PerFn PRODUNIT UNIT2)) ."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(minQuantValue,"A specialization of scalarBounds (q.v.) that relates a given ScalarInterval (q.v.) to the minimum ScalarPointValue (q.v.) it subsumes (see quantitySubsumes). (minQuantValue SCALAR POINT) means that the lower limit of SCALAR is POINT.\n

\nFor example, if all mailroom employees earned from five to eight dollars per hour, (minQuantValue \"MailroomPayRange\" (DollarsPerHour 5)) would hold. Other examples:\n

\n  (minQuantValue (Mile 15 20) (Mile 15))\n\n  (minQuantValue (Unity 6 12) 6).\n
\n

\nSee also maxQuantValue and pointQuantValue."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(minimizeExtent,"An instance of both MetaKnowledgePredicate and MetaPredicate (qq.v.) that is used to state that the Cyc system will \"assume\" that a (sequence of) thing(s) is not in the extension (see relationExtension) of a given predicate if the CycInferenceEngine is unable to prove that it is. \n

\n(minimizeExtent PRED) means that, for any sequence of things such that (PRED THING1 ... THINGn) holds, the fact that this holds is either expressed by some GAF (i.e. a \"ground atomic formula\"; see CycLClosedAtomicSentence) that is asserted in the Cyc Knowledge Base or is deducible via the inference engine from what is in the KB. \n

\nThe practical import of a minimizeExtent assertion is that it reflects an underlying assumption that if the inference engine cannot prove some given sentence of the form (PRED ARG1 ... ARGN), then that fact constitutes an argument for its negation (not (PRED ARG1 ... ARGN)); and, if the \"negation by failure\" inference parameter is turned on, the inference engine will actually conclude that this negation is true. Note that a minimizeExtent assertion is weaker than the corresponding completeExtentEnumerable (q.v.) assertion would be, in that the latter does not require that the inference engine attempt to deduce (PRED ARG1 ... ARGn) before concluding that it is not true. See also minimizeExtentForArg and the shared NoteOnClosedWorldAssumption."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(minimize,"minimize allows Cyc to assume that a statement is not\ntrue unless it is known to be true. Specifically, if for some\nbindings of the variables that appear in the minimized formula the\nformula with the bindings substituted in cannot be proved, then assume\nthe negation of the formula with the bindings substituted in. From an\nexample in the KB: (minimize (disjointWith ?Collection\n?Collection)) and binding ?Collection to Poodle means if we cannot\nprove (disjointWith Poodle Poodle) assume (not (disjointWith\nPoodle Poodle, i.e. assume every Collection is nonempty unless\nwe know otherwise. In the case where we bind ?Collection to some\nother variable ?Y and substituting in means if we cannot show\n(disjointWith ?Y ?Y) then assume the negation, (not (forAll ?Y\n(disjointWith ?Y ?Y))) which is equivalent to (thereExists ?Y\n(not (disjointWith ?Y ?Y))). This is one of the predicates that\nhas been created to allow Cyc to do negation by failure. Other\nrelated predicates are minimizeExtent and minimizeExtentForArg. "),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(microtheoryDesignationArgnum,"Used to specify which argument of a given MicrotheoryDesignatingRelation\ndesignates the microtheory in which to interpret some formula."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(meetsPragmaticRequirement,"A MetaKnowledgePredicate that is used to express that a pragmatic precondition on a given rule is satisfied. The predicate takes as arguments a list of CycL variables and an asserted rule (see CycLRuleAssertion) in which those variables occur \"free\". At the EL (\"epistemological level\"), meetsPragmaticRequirement sentences are not asserted as GAFs, but appear instead as the consequents of system-generated implies rules. For a given sequence of values for the respective variables VAR1, ..., VARn, (meetsPragmaticRequirement (TheList VAR1 ... VARn) RULE) means that some pragmatic precondition placed on RULE's being used by the Cyc inference engine (see pragmaticRequirement) is satisfied with respect to those values.\n

\nLet's make this more precise and explicit. A pragmatic precondition for a rule is written like so:\n

\n

\n   (pragmaticRequirement CONDITION RULE)\n
\n

\nand gets canonicalized into a rule involving meetsPragmaticRequirement like so:\n

\n

\n   (implies\n     CONDITION\n    (meetsPragmaticRequirement (TheList VAR1 ... VARn) RULE)),\n
\n

\nwhere VAR1, ..., VARn are all and only the variables that occur free in RULE and thus include all (and possibly only) the variables that occur free in CONDITION (i.e. as RULE and CONDITION explicitly appear in the KB browser, without consideration of their having \"implicit\" initial universal quantifiers).\n

\nThe above meetsPragmaticRequirement rule is used in inference similarly to an abnormal rule. If CONDITION is not known to hold for a given sequence of values for its variables , then those values do not \"meet the pragmatic requirement\" for RULE; and hence inference will not proceed using with RULE.\n

\nThe effect of the foregoing is that any asserted rule RULE is implicitly treated by the Cyc inference engine as if it had the form\n

\n

\n (implies\n  (meetsPragmaticRequirement (TheList VAR1 ... VARn) RULE)\n   RULE)\n
\n

\n(with VAR1, ..., VARn as described above).\n

\nThis convention allows the logical content of a rule to be expressed independently of any pragmatic preconditions for its being used in inference. If a rule has multiple pragmatic requirements, it must meet all of them to be used in inference.\n

\nAlso see abnormal, which is syntactically similar and has a related interpretation."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(maxQuantValue,"A specialization of scalarBounds (q.v.) that relates a given ScalarInterval (q.v.) to the maximum ScalarPointValue (q.v.) it subsumes (see quantitySubsumes). (maxQuantValue SCALAR POINT) means that the upper limit of SCALAR is POINT.\n

\nFor example, if all mailroom employees earned from five to eight dollars per hour, (maxQuantValue \"MailroomPayRange\" (DollarsPerHour 8)) would hold. Other examples:\n

\n  (maxQuantValue (Mile 15 20) (Mile 20))\n\n  (maxQuantValue (Unity 6 12) 12).\n
\n

\nSee also minQuantValue and pointQuantValue."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(maxQuantValue,"(maxQuantValue SCALAR POINT) means that the upper limit of the quantity SCALAR is POINT, an instance of ScalarPointValue. SCALAR is an instance of ScalarInterval. For example, the maxQuantValue for the pay of mail room employees might be (DollarsPerHour 6.5); e.g., (maxQuantValue `MailPay' (DollarsPerHour 6.5)). Another example: (maxQuantValue (Unity 5 10) 10)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ist,"This predicate relates a microtheory to any sentence that is true in it. (ist MT SENT) means that the CycL sentence SENT (or, if you prefer, the proposition SENT expresses) is true in the microtheory MT. Note that SENT need not actually be _asserted_ in MT; MT might for example \"inherit\" SENT from a more general microtheory. (Cf. ist-Asserted.)"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(isa,"A TaxonomicSlot (q.v.) that relates things of any kind to collections (see Collection) of which they are instances. (isa THING COL) means that THING is an instance of the collection COL. isa is by far the most commonly-occurring predicate in the Cyc Knowledge Base, and is one of the relations most fundamental to the Cyc ontology. An important logical feature of isa is that it \"transfers through\" genls (q.v.): (isa THING COL) and (genls COL SUPERCOL) jointly imply (isa THING SUPERCOL). This logical feature is expressed in a rule that -- along with various other rules that also sanction the derivation of isa sentences -- has been asserted to the Knowledge Base. As a result, only a small fraction of the isa based ground atomic formulas (or \"GAF\"s; see CycLClosedAtomicSentence) the Cyc system \"knows\" to be true have been manually asserted; the vast majority have been derived, or are derivable, automatically by the Cyc inference engine via the use of such rules. See also elementOf."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(irrelevantTerm,"A CycInferenceHeuristicRelevancePredicate. (irrelevantTerm TERM) states that the CycLClosedDenotationalTerm TERM should be heuristically considered less relevant to inferences made in the current Microtheory. See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(irrelevantPredAssertion,"(irrelevantPredAssertion PREDICATE ASSERTION) states that the given ASSERTION should be heuristically considered very unlikely to be relevant to inferences concluding uses of the given PREDICATE in the current mt. See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(irrelevantAssertion,"A CycInferenceHeuristicRelevancePredicate. (irrelevantAssertion ASSERTION) states that the CycLAssertion ASSERTION should be heuristically considered very unlikely to be relevant to inferences in the current Microtheory. See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(interArgResultIsa,"A quaternary MetaRelation predicate for stating that a certain kind of complex, partly isa -based relationship holds between a given argument to a given function and the corresponding value that is returned.\n

\n(interArgResultIsa FUNC N INDEP-ARG-COL DEP-ARG-COL) means that, when an instance of INDEP-ARG-COL appears as the Nth argument to FUNC, then (regardless of what the other arguments to FUNC might be) the value (if any) of that function for those arguments is an instance of DEP-ARG-COL. That is: if INST is an instance of INDEP-ARG-COL and (FUNC ARG1 ... ARGN-1 INST ...) = VALUE, then VALUE is an instance of DEP-ARG-COL.\n

\nFor example, (interArgResultIsa RoundUpFn 1 RealNumber Integer) means that the rounding-up function RoundUpFn returns an integer whenever it is given a real number as its first (and only) argument.\n

\nNote that, unlike (e.g.) the InterArgTypePredicates, interArgResultIsa cannot be used to put semantic well-formedness constraints on functions. See also the similar but less flexible ternary interArg1ResultIsa et al."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(interArgResultGenl,"A quaternary MetaRelation predicate for stating that a certain kind of complex, partly genls based relationship holds between a given argument to a given function and the corresponding value that is returned. (interArgResultGenls FUNC N INDEPENDENT-ARG-COL DEPENDENT-ARG-COL) means that, when a subcollection of INDEPENDENT-ARG-COL appears as the Nth argument to FUNC, then (regardless of what the other arguments to FUNC might be) the value (if any) of that function for those arguments is a subcollection of DEPENDENT-ARG-COL. That is: if INST is a subcollection of INDEPENDENT-ARG-COL and (FUNC ARG(1) ... ARG(N-1) INST ...) = VALUE, then VALUE is a subcollection of DEPENDENT-ARG-COL. Note that, unlike (e.g.) the InterArgTypePredicates, interArgResultGenl _cannot_ be used to put semantic well-formedness constraints on functions. See also the similar but less flexible ternary interArg1ResultGenls et al."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(integerBetween,"A ternary IntangibleObjectRelatingPredicate that holds among Integers only. (integerBetween LOW MED HIGH) means that HIGH is greaterThanOrEqualTo MED, and MED is greaterThanOrEqualTo LOW."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(independentArg,"A MetaPredicate that is used to state, of a given\n(ternary) InterArgConstraintPredicate, that it is (always) used to constrain a relation in such a way that a certain specified argument-place of the relation is for the \"independent\" argument (with respect to that constraint). (independentArg INT-ARG-PRED N) means that any sentence of the form (INT-ARG-PRED RELN ...) constrains RELN in some way that treats RELN's Nth argument as independent. For example, (independentArg interArgIsa3-4 3) holds. See the comment on InterArgConstraintPredicate for an explanation of what it means to be an \"independent\" argument in this sense. Note that independentArg is contrained to apply only to _ternary_ inter-argument constraint predicates, as only they have already-fixed positions for the corresponding independent and dependent arguments; thus it cannot (on pain of semantic malformedness) be applied to the quintary inter-argument constraint predicates, such as interArgIsa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(implies,"A binary LogicalConnective (q.v.) that corresponds to the material implication operator of propositional calculus. The implies relation takes two CycLSentence-Assertibles as its arguments; and the syntactic result of applying the term 'implies' to two sentences is itself a sentence, called a \"conditional\" or \"implication\". A sentence of the form (implies ANTECEDENT CONSEQUENT) is true if and only if ANTECEDENT is false or CONSEQUENT is true (or both). Equivalently: it is not the case that ANTECEDENT is true and CONSEQUENT is false. For example,\n

\n

\n  (implies\n    (knows Muffet Patches-Cat)\n    (likesAsFriend Muffet Patches-Cat))\n
\n

\nmeans that if Muffet knows Patches then she likes him.\n

\nCf. the predicate sentenceImplies, which is not a logical connective, and is primarily used in rules involving quantification over CycL sentences."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(hypotheticalTerm,"(hypotheticalTerm TERM) states that TERM is a term that was hypothesized. The most common reason a term is hypothesized is to pose a hypothetical query to Cyc."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(holdsIn,"An instance of both TemporalPredicate and ModalPredicate that is used to state (in a somewhat indirect way) that a given sentence is true during a certain time period. (holdsIn TEMP SENT) means that SENT is true at every moment in the temporalExtent (q.v.) of the TemporalThing TEMP.\n

\nFor example, the sentence (holdsIn (YearFn 2003) (hasPets Curtis Patches-Cat)) means that throughout all of the year 2003 Curtis had Patches as a pet. This entails (e.g.) that Curtis had Patches on 5 July 2003:\n

\n  (holdsIn\n    (DayFn 5 (MonthFn July (YearFn 2003)))\n    (hasPets Curtis Patches-Cat)) .\n
\n

\nSimilarly, (holdsIn Patches-Cat (hasPets Curtis Patches-Cat)) means that Curtis has Patches as a pet for Patches's entire life.\n

\nSee also the more general predicate holdsSometimeDuring.\n

\nNote that a sentence of the form (holdsIn TEMP (PRED ... ARGi ...)), where ARGi is a TemporalThing, does not in general imply that ARGi temporally subsumes or even temporally intersects TEMP. For example, (holdsIn (YearFn 2003) (awareOf Curtis GeorgeWashington)) obviously doesn't imply that GeorgeWashington was alive in 2003. ARGi's temporally subsuming TEMP does follow, however, if PRED is a CotemporalPredicate that is contemporaryInArg (q.v.) in its ith argument-place (as hasPets is, in both argument-places).\n

\nNote also that there are two other ways to temporally-qualify sentences in CycL, which do not involve using holdsIn (or holdsSometimeDuring). Both involve temporally qualifying the Microtheory in which the (otherwise unqualified) sentence is asserted, and either can be used to state something roughly equivalent to a holdsIn sentence. Consider the first Curtis/Patches example above. First, one could assert (hasPets Curtis Patches-Cat) in some microtheory MT such that (holdsInTime-Always MT (YearFn 2003)). Second, one could assert (hasPets Curtis Patches-Cat) in a microtheory MT' such that both (mtTimeIndex MT' (YearFn 2003)) and (mtTimeParameter MT' TimePoint) hold. This later method, being the most developed and well-supported, is generally preferred over the others.\n

\nNote finally that it would be incorrect to assert a sentence like (hasPets Curtis Patches-Cat) in a non-temporally-qualified microtheory like the BaseKB, since Curtis didn't have Patches when (e.g.) he was a young boy, let alone in 3500 BCE."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(hlPrototypicalInstance,"(hlPrototypicalInstance TERM COL) means that TERM is a prototypical instance of COL at the HL. It is assumed that TERM has only two asserted assertions on it: one hlPrototypicalInstance assertion and one assertion of the form (isa TERM COL). The CycInferenceEngine makes use of the prototypical instance during assertions to cache the work done by forward inference. It is used when asserting the first isa assertion on a term with no other assertions about it yet. Do not assert comments, cyclistNotes or any other assertions on prototypical instances. They are intentionally minimal."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(highlyRelevantTerm,"A CycInferenceHeuristicRelevancePredicate. (highlyRelevantTerm TERM) states that the CycLClosedDenotationalTerm TERM should be heuristically considered highly relevant to inferences made in the current Microtheory. See also other instances of CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(highlyRelevantPredAssertion,"(highlyRelevantPredAssertion PREDICATE ASSERTION) states that the given ASSERTION should be heuristically considered highly relevant to inferences concluding uses of the given PREDICATE in the current mt. See also other instances CycInferenceHeuristicRelevancePredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(highlyRelevantMt,"A CycInferenceHeuristicRelevancePredicate. (highlyRelevantMt MT) means that all assertions in the Microtheory MT should be heuristically considered highly relevant to inferences done in the Microtheory MT-1 in which (highlyRelevantMt MT) is asserted (where MT-1 and MT need not be the same). As a consequence, note that when (highlyRelevantMt MT) is asserted in a Microtheory MT-1, each of the assertions in MT will be a highlyRelevantAssertion (q.v.) for inferences done in MT-1."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(greaterThanOrEqualTo,"A NumericComparisonPredicate (q.v.) that is a generalization of the mathematical greater-than-or equal-to (>=) relation to ScalarIntervals (q.v.) of all sorts, including quantitative intervals (see NumericInterval and Quantity) as well as point values (see ScalarPointValue). (greaterThanOrEqualTo VALUE1 VALUE2) means that VALUE1 is greater than or equal to VALUE2 with respect to some scale that they are both on. More precisely, there is some TotallyOrderedScalarIntervalType SCALE that both VALUE1 and VALUE2 are instances of and either (i) SCALE is a specialization of NumericInterval (e.g. RealNumber) and the minimum (see minQuantValue) of VALUE1 is greater than or equal to the maximum (see maxQuantValue) of VALUE2, (ii) (followingValueOnScale VALUE2 VALUE1 SCALE) holds, or (iii) (equals VALUE1 VALUE2) holds.\n

\nSee also greaterThan and lessThanOrEqualTo."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(greaterThan,"A NumericComparisonPredicate that is a generalization of the mathematical greater-than ( > ) relation to ScalarIntervals (q.v.) of all sorts, including quantitative intervals (see NumericInterval and MeasurableQuantity) as well as point values (see ScalarPointValue). (greaterThan VALUE1 VALUE2) means that VALUE1 is greater than VALUE2 with respect to some scale that they are both on. More precisely, there is some TotallyOrderedScalarIntervalType SCALE that both VALUE1 and VALUE2 are instances of and either (i) SCALE is a specialization of NumericInterval (e.g. RealNumber) and the minimum (see minQuantValue) of VALUE1 is greater than the maximum (see maxQuantValue) of VALUE2 or (ii) (followingValueOnScale VALUE2 VALUE1 SCALE) holds."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genMassNoun,"(genMassNoun TERM) means that the CycLReifiableDenotationalTerm TERM should be treated as a mass noun when CycL formulae containing TERM are paraphrased into English. See also the related predicate prettyName."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genls,"A instance of TaxonomicSlotForCollections (q.v.) and a specialization of generalizations. genls relates a given collection (see Collection) to those collections that subsume it. More precisely, (genls SUBCOL SUPERCOL) means that SUPERCOL is a supercollection of SUBCOL: anything that is an instance of (see isa) SUBCOL is also an instance of SUPERCOL. For example, (genls Dog Mammal) holds. genls is one of the most commonly-occurring predicates in the Cyc Knowledge Base, and one of the relations most fundamental to the Cyc ontology. See also subsetOf."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genlRules,"(genlRules RULE-SPEC RULE-GENL) means that the set of binding tuples that satisfy the open (universally quantified) variables in the consequent of RULE-SPEC via an application of RULE-SPEC will be a subset of the set of binding tuples that satisfy the open (universally quantified) variables in the consequent of RULE-GENL via an application of RULE-GENL. For example, the following holds\n\n

\n   (genlRules\n      (ist CCFBridgingMt\n        (implies\n          (and\n           (cCFCardiacValveRepairProcedure ?CVRP Plication-ValvularProcedure)\n           (rdf-type ?PROC HeartValveRepair-SurgicalProcedure)\n           (cCF-contains ?CVD ?CVRP)\n           (cCF-contains ?PROC ?CVD))\n          (isa ?PROC Plication-ValvularProcedure)))\n      (ist CCFBridgingMt \n       (implies\n         (rdf-type ?X HeartValveRepair-SurgicalProcedure)\n         (isa ?X HeartValveRepair-SurgicalProcedure))))
\n\n\nHence, if one was looking to return instances of HeartValveRepair-SurgicalProcedure, all other things being equal, there would be no need to query using both of these rules. The rule in arg2 of genlRules here would get a superset of the answers that the rule in arg1 would return.\n "),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genlPreds,"A MetaPredicate for stating that one predicate is a generalization of another. (genlPreds SPEC-PRED GENL-PRED) means that GENL-PRED is a generalization of SPEC-PRED. That is, (GENL-PRED ARG1..ARGN) holds whenever (SPEC-PRED ARG1..ARGN) holds. For example, (genlPreds touches near) holds, as touching something implies being near it.\n

\nAs for the respective arities (see arity) of SPEC-PRED and GENL-PRED, (i) both predicates might have the same fixed-arity (see FixedArityRelation), (ii) both might have variable-arity (see VariableArityRelation), or (iii) SPEC-PRED might have a fixed-arity and GENL-PRED variable-arity. (It cannot be the case that SPEC-PRED has variable-arity and GENL-PRED has a fixed-arity.)\n

\nSee also negationPreds, genlInverse, and negationInverse."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genlMt,"A reflexive and transitive BinaryPredicate that relates a Microtheory to a Microtheory. (genlMt SPEC-MT GENL-MT) means that SPEC-MT is a specialization or extension of GENL-MT. (Note that it need not be a proper specialization or extension.) In particular, this entails that everything that is true in GENL-MT is also true in SPEC-MT. This relation is sometimes expressed informally by saying that SPEC-MT \"sees\" GENL-MT."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genlInverse,"A MetaPredicate for stating that one binary predicate is a generalization of the inverse of another binary predicate. (genlInverse PRED GENL-INV-PRED) means that GENL-INV-PRED is a \"generalized inverse\" of PRED. That is, (PRED ARG1 ARG2) implies (GENL-INV-PRED ARG2 ARG1). For example, (genlInverse grandchildren ancestors) means that grandparents are ancestors of their grandchildren. See also genlPreds and negationInverse."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(genKeyword,"An NLGenerationPredicate that\nrelates a given CycL denotational term to the SubL keyword \nthat is used to represent it in generating natural language \nfrom CycL. (genKeyword CYCL-TERM KEYWORD) means that \nKEYWORD represents CYCL-TERM in the generation of natural \nlanguage paraphrases of CycL expressions, e.g. in genFormat \n(q.v.) assertions."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(forwardNonTriggerLiteral,"An HLPredicate that is used to state which literals in a forward rule should not be allowed to re-trigger forward inference. This is useful for placing pragmatic restrictions on the applicability of forward rules. It is only useful when used via pragmaticRequirement on a forward rule.\n

\nA pragmatic requirement of the form\n

\n(pragmaticRequirement (forwardNonTriggerLiteral FORMULA) RULE),\n
\nwhere FORMULA is a literal in the antecedent of RULE, ensures that new assertions that are instantiations of FORMULA do not trigger RULE."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(all,"A binary Quantifier that corresponds to the standard universal quantifier of predicate calculus. The relation forAll takes as its arguments a variable (ELVariable) and a sentence (ELSentence-Assertible) in which, typically, that variable occurs free. A closed formula (see CycLClosedFormula) of the form (forAll VAR SENT) is a \"universally quantified\" sentence that states (roughly) that every thing in the universe of discourse satisfies SENT. For example,\n

\n

\n  (forAll ?THING (isa ?THING Individual))\n
\n

\nmeans that everything is an individual. And the sentence\n

\n

\n  (forAll ?X\n    (implies\n      (isa ?X Cat)\n      (eatsWillingly ?X Grass-Plant)))\n
\n

\nmeans that all cats eat grass.\n

\nA more precise definition of forAll is as follows. Any occurence of VAR that is free in SENT is bound in (forAll VAR SENT). If VAR is the only variable free in SENT, then (forAll VAR SENT) is a closed sentence that is true if and only if every thing that meets all of the argument-type constraints (see ArgTypePredicate) to which the position(s) in SENT occupied by VAR is (are) subject to satisfies SENT. If the variable VAR does _not_ occur free in SENT, then (forAll VAR SENT) is equivalent to SENT (and the 'forAll' is said to be \"vacuous\"). If variables other than VAR occur free in SENT, then (forAll VAR SENT) is an open sentence in which those other variables are still free.\n

\nNote that, for the sake of convenience and readability, universally quantified assertions (i.e. \"rules\") in the Cyc Knowledge Base appear in the KB browser -- and may be asserted to the KB -- without (any of) their initial 'forAll's. Such assertions are considered to be \"implicitly quantified\": they are interpreted by the system just as if their initial quantifiers were explicitly present. Thus the above sentence about cats would actually appear in the KB as:\n

\n

\n  (implies\n    (isa ?X Cat)\n    (eatsWillingly ?X Grass-Plant)) .\n
\n

\nNote also that certain RuleMacroPredicates (e.g. those with 'All' in their names) can be used to abbreviate universally quantified sentences. Thus the same statement about cats can be even more tersely expressed with the atomic sentence\n

\n

\n  (relationAllInstance eatsWillingly Cat Grass-Plant) .\n
\n

\nCf. the existential quantifier thereExists."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(followingValue,"An instance of both OrderingPredicate and ComparisonPredicate (qq.v.), and a specialization of both colinearQuantities and lessThan (qq.v.). followingValue is simply the restriction of the very general lessThan relation to colinear Quantity[ies] (q.v.). (followingValue LO-QUANT HI-QUANT) means that LO-QUANT and HI-QUANT are colinear quantities such that HI-QUANT is a higher or greater value than LO-QUANT. It follows that there is some (unspecified) linear ordering (see TotallyOrderedQuantityType) to which both LO-QUANT and HI-QUANT belong.\n

\nNote that the above sentence would typically be asserted only if one or both of LO-QUANT and HI-QUANT are instances of GenericQuantity (or the more general NonNumericScalarQuantity), and -- as is usually the case -- they are not grounded in numerically-quantifiable units of measure (see NoteAboutGivingGenericValueFunctionsNumericValues). If LO-QUANT and HI-QUANT do have numerical grounding, a followingValue assertion is unnecessary since numericallyEquals, greaterThanOrEqualTo, and greaterThan are automatically computable using arithmetic relations holding between the respective minimums and maximums (see minQuantValue and maxQuantValue) of LO-QUANT and HI-QUANT. For example, one might well use followingValue to state that (HighAmountFn Glamour) is more glamorous than (LowAmountFn Glamour); but it is unnecessary to make a followingValue assertion about (MilesPerHour 5) and (MilesPerHour 25 35), since greaterThan is automatically computable in that case.\n

\nSee also GenericValueFunction and followingValueOnScale."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(fanOutArg,"(fanOutArg PRED N) means that transitively-related assertions using PRED usually \"fan out\" in the direction of argument position N. For example, (fanOutArg geographicalSubRegions 2) means that usually a geographical region has more direct sub-regions than super-regions, so for any region REG there will likely be more assertions of the form (geographicalSubRegions REG SUB) than there are assertions of the form (geographicalSubRegions SUPER REG)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(expansionDefn,"(expansionDefn ) denotes that during canonicalization\nthe subl function definition of is used to transform an EL expression\n( . ) into the appropriate HL formula."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(expansion,"Some relations (namely, instances of MacroRelation (q.v.)) can be defined in terms of more basic or primitive constructs. (expansion RELATION FORMULA) associates RELATION with the FORMULA that defines it. The arg2 is allowed to reference generic-argument keywords, such as :ARG1 :ARG2 which represent respectively the arg1 and the arg2 within uses of RELATION. For example, (expansion genls (implies (isa ?object :ARG1) (isa ?object :ARG2))) indicates that the gaf (genls Poodle Dog) is defined as (implies (isa ?object Poodle) (isa ?object Dog))). Importantly, the expansion-formula arg2 must be necessary and sufficient; it denotes the definition of the uses of relation arg1; there can be only one expansion for any relation. Furthermore, no two relations can share a common expansion; thus, there can be only one possible contraction from a formula that corresponds to an expansion into a compact form that references expandable relations. For example, (implies (isa ?object Poodle) (isa ?object Dog))) has the unambiguous contraction of (genls Poodle Dog). The expansion arg2 can (and should when possible) make use of relations that have expansions. Note that the example above references implies which would itself have the expansion (or (not :ARG1) :ARG2). Thus, the full expansion of a relation can involve recursive expansions. For example, the full expansion of genls would be (or (isa ?object :ARG1) (not (isa ?object :ARG2)))). No relation may reference itself (either directly or indirectly via recursion) in its expansion (or in its full recursive expansion). See ELRelation, TermMacroFunction, expansionAxiom."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(exceptWhen,"A binary ExceptionPredicate that relates a general CycLAssertion to a condition (specified by a CycLSentence-Assertible) under which the assertion fails to hold, and thus under which the assertion should not be used as justification for other inferences. (exceptWhen EXCEPTION ASSERTION) means that ASSERTION fails to hold in the case of EXCEPTION. A default assumption is that ASSERTION does hold for all cases other than those covered by EXCEPTION (or by any other exception assertions there might be on ASSERTION). For example, \n

\n  (exceptWhen\n    (spatiallySubsumes NorthPoleOfEarth ?THING)\n    (implies \n      (isa ?THING GeographicalThing) \n      (thereExists ?OTHER \n        (northOf ?OTHER ?THING)))\n
\t\nmeans that every geographical thing has something to the north of it, except when the former is spatially subsumed by the North Pole. \n

\nNormally, as in the foregoing example, the ASSERTION is an (implicitly) universally quantified sentence, and the EXCEPTION, in effect, places a restriction on the range of values (for the universally quantified variables in ASSERTION) for which ASSERTION is true. Since implicit universal quantification is always interpreted as having the widest possible scope, in the above example the occurrence of the variable ?THING in the exception-giving sentence is interpreted as if it were bound by the same wide-scope universal quantifer that binds the two occurrences of ?THING in the implies rule.\n

\nA common special case of exceptWhen is handled by exceptFor (q.v.). \n

\nNote that assertions made at the EL level with exceptWhen are canonicalized into statements that do not contain exceptWhen, but instead contain the predicate abnormal (q.v.)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(exceptFor,"A binary ExceptionPredicate that relates a general CycLAssertion to a thing (specified by a CycLReifiableDenotationalTerm) for which the assertion fails to hold, and thus under which the assertion should not be used as justification for other inferences. (exceptFor TERM ASSERTION) means that ASSERTION fails to hold for the denotatum of TERM. A default assumption is that ASSERTION does hold for everything other than the denotatum of TERM (or any other known exceptions there might be on ASSERTION). For example,\n

\n     (exceptFor\n      Taiwan-RepublicOfChina\n      (implies\n        (isa ?X ChineseProvince)\n        (geopoliticalSubdivision China-PeoplesRepublic ?X)))\n
\nmeans that Taiwan-RepublicOfChina is an exception to the rule that every Chinese province is a geo-political subdivision of the People's Republic of China.\n

\nexceptFor is a special case of exceptWhen (q.v.), and is only applicable when ASSERTION has exactly one (implicitly) universally quantified variable. (exceptFor TERM ASSERTION) prevents TERM from binding to that variable, thereby blocking any conclusions about the denotatum of TERM that Cyc might otherwise draw from ASSERTION.\n

\nNote that assertions made at the EL level with exceptFor are canonicalized into statements that do not contain exceptFor, but instead contain the predicate abnormal (q.v.)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(exampleAssertions,"(exampleAssertions TERM ASSERTION) means that the CycLAssertion ASSERTION provides a good example of how to use the CycLReifiableDenotationalTerm TERM."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(evaluationDefn,"A CycInferenceDescriptorPredicate and InferenceRelatedBookkeepingPredicate that is used to relate an Cyc-evaluatable function or predicate to the name of the piece of code that is used to evaluate it. (evaluationDefn RELN NAME) means that the SubLSymbol NAME is the name of a piece of Heuristic Level (SubL) code in the Cyc system that is used to compute the value of closed CycL formulas built from (the CycL name of) the EvaluatableRelation RELN. For example, the sentence '(evaluationDefn MinusFn CYC-MINUS)' is asserted in the Knowledge Base.'"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(evaluateImmediately,"(evaluateImmediately FUNCTION) means that the canonicalizer will translate each non-atomic term (see the collection CycLNonAtomicTerm) whose initial (or \"0th\" argument-place) term denotes FUNCTION into the value to which the non-atomic term evaluates. For example, if (evaluateImmediately PlusFn) held, then the non-atomic term `(PlusFn 2 3 4)' would canonicalize as `9'. Note that a non-atomic term containing a nested non-atomic term whose initial term denotes another instance of EvaluatableFunction (call that instance OTHER-FUNCTION) will not canonicalize in this way, unless (evaluateImmediately OTHER-FUNCTION) is also true. For example, `(PlusFn 2 (DifferenceFn 3 4))' would not canonicalize as `1' unless \n(evaluateImmediately DifferenceFn) were also true."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(evaluateAtEL,"(evaluateAtEL FUNCTION) means that the canonicalizer will translate each non-atomic term (see the collection CycLNonAtomicTerm) whose initial (or \"0th\" argument-place) term denotes FUNCTION into the value to which the non-atomic term evaluates. For example, if (evaluateAtEL PlusFn) holds in a Microtheory MT, then the non-atomic term `(PlusFn 2 3 4)' will canonicalize as `9' in that MT. Note that a non-atomic term containing a nested non-atomic term whose initial term denotes another instance of EvaluatableFunction (call that instance OTHER-FUNCTION) will not canonicalize in this way, unless (evaluateAtEL OTHER-FUNCTION) is also true in MT. For example, `(PlusFn 2 (DifferenceFn 3 4))' will not canonicalize as `1' in MT unless \n(evaluateAtEL DifferenceFn) is also true in MT."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(evaluate,"A binary MetaLanguagePredicate that relates a thing to a thing that is known to denote it. (evaluate THING TERM) means that TERM evalutes to THING: the Cyc system \"knows\" that TERM denotes THING.\n

\nNote that evaluate is notAssertible (q.v.). Its most common uses are in rules or queries, with its first argument-place filled (syntactically speaking) with a variable. In a query, evaluate is typically used to establish a binding between such a variable and an evaluatable expression. If VAR is a variable, a literal of the form (evaluate VAR TERM) is satisfied by an HL module that evaluates TERM and binds VAR to the result. For example, the literal '(evaluate ?SUM (PlusFn 1 2))' would bind '?SUM' to 3. If evaluate's arg1 position is filled instead with a closed expression, then the HL module checks to see if the arg2 term evaluates to the denotatum of that arg1 expression. For example, if asked the sentence '(evaluate 3 (PlusFn 1 2))' the system will return 'True'."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(equiv,"A LogicalConnective that represents bi-directional implication in CycL. It takes two arguments, each of which must be an instance of ELSentence-Assertible. (equiv FORMULA-1 FORMULA-2) means that FORMULA-1 is true precisely when FORMULA-2 is true; in other words, FORMULA-1 is true if and only if FORMULA-2 is true. (An EL equiv formula is translated during canonicalization into an equivalent, less compact, conjunction of implies formulas.) See also the predicate sentenceEquiv."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(equalSymbols,"A binary MetaPredicate and a specialization of equals, both of whose arguments are quotedArguments (q.v.), that can be used to make identity assertions about symbols. Stated loosely, (equalSymbols X Y) means that X and Y are one and the same symbol. Given that the arguments are \"quoted\", however, it is more accurate to say: A closed atomic formula consisting of the expression equalSymbols followed by CycL expressions A and B (all enclosed within a pair of parentheses) is true if and only if A and B are (two occurrences of) the same expression.\n

\nNote that this is stronger than merely saying that A and B denote the same thing. As an example (using English expressions for convenience), the name 'Bertrand Russell' and the description 'the author of \"On Denoting\"' are two different expressions, even though they both denote the same person. Two symbols can even share the same intensional meaning and still be different symbols; e.g. 'bachelor' and 'unmarried male'. The relation equalSymbols does hold, however, between 'bachelor' and 'bachelor' (at least if we pretend that 'bachelor' is a CycL expression), as it does between the CycL constant BertrandRussell and the CycL constant BertrandRussell.\n

\nSee also differentSymbols."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(equals,"The binary identity relation. (equals THING1 THING2) means that THING1 and THING2 are \"numerically\" (as opposed to \"qualitatively\") identical, i.e. they are one and the same thing. A sentence of the above form is true if and only if the terms occupying the two argument-places of 'equals' denote the same thing."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(elInverse,"A binary RuleMacroPredicate and a specialization of genlInverse that relates a binary EL-only (see ELRelation-OneWay) predicate with its non-EL-only \"inverse correlate\". (elInverse PRED EL-PRED) means that whenever a sentence of the form (EL-PRED ARG1 ARG2) is used to make an assertion, the CycCanonicalizer \"transforms\" it into the logically equivalent form (PRED ARG2 ARG1), and the latter is what actually gets stored in the Knowledge Base.\n

\nFor example, (genlInverse genls specs) entails that if I assert the sentence '(specs Animal Cat)', what gets stored in the KB is the sentence '(genls Cat Animal)'."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(elementOf,"A very general binary predicate that relates a thing to any set or collection (see SetOrCollection) that it is a member or element of. (elementOf THING SETORCOL) means that THING is an element of SETORCOL. \n

\nelementOf is a more general relation than isa. Whereas isa is used exclusively to talk about membership in Collections, elementOf can also be used to talk about membership in mathematical sets (see Set-Mathematical)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(distributesOutOfArg,"(distributesOutOfArg ) is a directive to the canonicalizer that relation distrbutes out of a predicate when it appears as the top-most relation in the predicate's arg . Specifically, it denotes (distributesOutOfArg ) denotes that the canonicalizer will translate\n

\n( ... ( ... ) ..)\n

\ninto\n

\n( ( ... ...)\n( ... ...)\n...\n( ... ...))"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(disjointWith,"A TaxonomicSlot predicate that relates Collections (q.v.) that have no instances in common. (disjointWith COL1 COL2) means that COL1 is disjoint with COL2: nothing is an instance of both. That is, there is no THING such that both (isa THING COL1) and (isa THING COL2) hold. For example, (disjointWith Herbivore Carnivore) holds because no animal is both a herbivore and a carnivore. Note that disjointWith is not irreflexive (see IrreflexiveBinaryPredicate): it is possible for a collection to be disjoint with itself, though only if it is empty (i.e. has no instances). Thus, for example, (disjointWith Nothing Nothing) holds. Cf. intersectsWith.\n

\nAlso note that it is quite possible for two second (or higher) order collections to be disjoint even if an instance of one collection and an instance of the other collection themselves share instances. Consider, for example, the disjoint collections SpatialThingTypeByShape and SpatialThingTypeByDimensionality. RoundObject is an instance of the first and ThreeDimensionalThing is an instance of the second; and any solid spherical object is an instance of both of these latter collections."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(differentSymbols,"This variable-arity predicate (see VariableArityRelation), all of whose argument-places are quotedArguments (q.v.), is used to make non-identity statements about two or more symbols. Stated loosely, (differentSymbols X1 X2 ... Xn) means that each of the Xi is a symbol that is different from all of the others. Given that the arguments are \"quoted\", however, it is more accurate to say: A ground atomic formula (or \"GAF\"; see CycLClosedAtomicSentence) consisting of the expression `differentSymbols' followed by the CycL expressions E1, ..., En (all enclosed within a pair of parentheses) is true if and only if each Ei is a different expression from all of the others. Note that two symbols can denote the same thing (in ordinary circumstances) and still be different symbols. As an example (using English expressions for convenience), the proper name `Bertrand Russell' and the descriptive phrase `the author of \"On Denoting\"' are two different expressions, even though they both denote the same person. Two symbols can even share the same intensional meaning and yet be different symbols; e.g. `bachelor' and `unmarried man'. The sentence `(differentSymbols BertrandRussell BertrandRussell)', on the other hand, is false. See also equalSymbols and different."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(different,"A variable-arity predicate (see VariableArityRelation) that is used to state the non-identity of two or more things. (different THING1..THINGn) means that for any THINGi and THINGj (where 0 <= i <= n, 0 <= j <= n, and i =/ j), THINGi is not identical with THINGj. That is, each of THING1, ..., THINGn is distinct from all of the others. Cf. equals."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(defnSufficient,"A CycInferenceDescriptorPredicate. (defnSufficient COL TEST) means that TEST is the name of a piece of code in the SubL implementation of Cyc that specifies, and tests for, a sufficient condition for a CycL term's denoting an instance of (see isa) the collection COL. If TEST returns `T' (for `True') when applied to a particular term, then that term's denotatum is considered to be an instance of COL. Note that TEST isn't necessarily a necessary test for membership in COL; that is, not all instances of COL must pass the test, unless TEST is also a defnNecessary for COL. See the related predicates defnNecessary and defnIff."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(defnNecessary,"A CycInferenceDescriptorPredicate. \n(defnNecessary COL TEST) means that TEST is the name of a piece \nof code in the SubL implementation of Cyc that specifies, and tests \nfor, a necessary condition for a CycL term's denoting an instance of \n(see isa) the collection COL. Only if TEST returns `T' (for \n`True') when applied to a particular term can that term's \ndenotatum be considered an instance of COL; all terms that denote \ninstances of COL must fulfill TEST's requirements, although there \nmay be additional requirements for denoting an instance of COL as \nwell. See also defnSufficient and defnIff."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(defnIff,"A CycInferenceDescriptorPredicate. (defnIff COL TEST) means \nthat TEST is the name of a piece of code in the SubL implementation \nof Cyc that specifies, and tests for, a necessary and sufficient \ncondition for a CycL term's denoting an instance of (see isa) the \ncollection COL. If and only if TEST returns `T' (for `True') when \napplied to a particular term can that term's denotatum be considered \nan instance of COL; all and only terms that denote instances of COL \nmust fulfill TEST's requirements. See also defnNecessary and \ndefnSufficient."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(definingMt,"(definingMt TERM MT) states that TERM only begins to have semantic meaning in microtheory MT. In microtheories in which MT is not accessible, TERM is undefined. Additionally, (termDependsOn TERM MT)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(constraint,"(constraint RULE) labels a given RULE assertion as a constraint. Constraints are typically used to verify that a given logical expectation is already true, rather than to deduce (and then add) a new formula which would satisfy the expectation. In other words, if a rule (implies P(?X) Q(?X)) is labelled as a constraint, then when P(?X) is determined to be true, we verify that Q(?X) is already true rather than add a new argument for Q(?X) using the rule and P(?X) as justification."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(constrainsArg,"A MetaRelation predicate for stating that a given meta-relation is used to put an argument-type or format constraint (see e.g. ArgConstraintPredicate) on a given argument-place of a relation. (constrainsArg METARELN N) means that METARELN is always used to put a constraint on a relation's Nth argument-place. For example, (constrainsArg arg2Isa 2) holds. A slight deviation from the above occurs when N is 0: we take (constrainsArg METARELN 0) to mean that METARELN is used to constrain _all_ of a relation's argument-places; see e.g. argsIsa and argsGenl."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(consistent,"A predicate which asserts of sentences that they do not contradict currently known facts. (consistent SENTENCE) means that the CycLSentence-Assertible SENTENCE is consistent with assertions known in the current context. Consequently, (consistent SENTENCE) holds in a Microtheory MT just in case, for any assertion ASSERT that holds in MT, SENTENCE does not imply the negation of ASSERT. Note that this predicate is notAssertible. See also inconsistentWithMt."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(conceptuallyRelated,"This predicate is used to state the fact of a conceptual link between two things, where a very complex sentence would be required in order to describe the precise nature of this link explicitly. Examples of such conceptually-linked couples include PublicTransportationDevice / PublicTransportationScheduleDocument and Dog / DogFood. The rationale for having such a predicate as conceptuallyRelated is similar to that behind many RuleMacroPredicates (q.v.). Having complex relationships represented -- possibly redundantly -- in a more compact fashion makes for faster retrieval. Because things can be conceptually related in many different ways, no explicit definition for this predicate is provided. Note that conceptuallyRelated is _not_ a SymmetricBinaryPredicate (q.v.); but see conceptuallyCoRelated for a specialization of this predicate that is symmetric."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(commutativeInArgsAndRest,"A variable-arity MetaRelation used for \nstating that a given PartiallyCommutativeRelation (q.v.) is \"commutative\" \nwith respect to two or more argument-places, including all argument-places that \ncome after the ordinally highest one that is explicitly specified. \n(commutativeInArgsAndRest RELN ARGNUM-1 ARGNUM-2 ... ARGNUM-N) means that \nRELN is commutative in its ARGNUM-1th, ARGNUM-2th, ..., and ARGNUM-Nth \narguments-places, along with any of its argument-places whose ordinal positions \nare greater than the greatest of the ARGNUM-i. Thus RELN admits unrestricted \npermutation among any of these arguments. More precisely (and assuming without \nloss of generality that ARGNUM-N is the numerically greatest of the ARGNUM-i): \n(i) if RELN is a Predicate that holds of a given argument-sequence SEQ, then \nRELN also holds of any other sequence SEQ-PERMUTE obtainable from SEQ by \npermuting some or all of SEQ's ARGNUM-1th, ARGNUM-2th, ..., ARGNUM-Nth, and \nsubsequent items (while leaving all of SEQ's other items unchanged). \n(ii) if RELN is a Function-Denotational that associates a given \nargument-sequence SEQ with the value VALUE, then RELN also associates any \nsequence SEQ-PERMUTE (as described above) with VALUE. For example, \n(commutativeInArgsAndRest commutativeInArgsAndRest 2) \nhas as a consequence that whenever a sentence of the form \n(commutativeInArgsAndRest RELN 2 3 5) holds, so do the corresponding \nsentences (commutativeInArgsAndRest RELN 2 5 3), \n(commutativeInArgsAndRest RELN 3 2 5), and so on. Note that since RELN \nis an instance of PartiallyCommutativeRelation, it must have at \nleast two argument-places that are commutative with each other and at \nleast one that is _not_ commutative with any other argument-place. See\nalso commutativeInArgs."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(commutativeInArgs,"A variable-arity MetaRelation used for stating that a given PartiallyCommutativeRelation (q.v.) is \"commutative\" with respect to two or more specified argument-places.\n

\n(commutativeInArgs RELN ARGNUM-1 ... ARGNUM-N) means that RELN is commutative in its ARGNUM-1th, ..., and ARGNUM-Nth arguments. Thus RELN admits unrestricted permutation among these arguments. More precisely: (i) if RELN is a Predicate that holds of a given argument-sequence SEQ, then RELN also holds of any other sequence SEQ-PERMUTE obtainable from SEQ by permuting some or all of SEQ's ARGNUM-1th, ..., and ARGNUM-Nth items (while leaving all of SEQ's other items unchanged). (ii) if RELN is a Function-Denotational that associates a given argument-sequence SEQ with the value VALUE, then RELN also associates any sequence SEQ-PERMUTE (as described above) with VALUE.\n

\nFor example, (commutativeInArgs formsBorderBetween 2 3) has as a consequence that whenever a sentence of the form (formsBorderBetween BORDER REG1 REG2) holds, so does the corresponding sentence (formsBorderBetween BORDER REG2 REG1).\n

\nIf RELN is commutative in at least two argument-places it is an AtLeastPartiallyCommutativeRelation. If RELN is commutative in all argument-places it is, more specifically, a CommutativeRelation. If RELN is commutative in at least two, but not all,\nargument-places it is, instead, a PartiallyCommutativeRelation.\n

\nNote that the fact that each argument-place of a given relation commutes with some other argument-place is not sufficient for its being fully commutative. For example, a partially-commutative quaternary relation might be such that its first and third places commute with each other and its second and fourth places commute with each other."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(comment,"A DocumentationPredicate (q.v.) that is used to relate a CycLIndexedTerm (usually a CycLConstant) to a SubLString containing an English explanation of the term's meaning and use, as an aid to humans (whether Cyclists or not) browsing the Cyc Knowledge Base. (comment TERM STRING) means that STRING is a piece of Cyc documentation that explains the meaning and use of TERM. For example, the passage you are reading now is the comment for the CycL constant `comment'. See also cyclistNotes."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(coExtensional,"A TaxonomicSlotForCollections (q.v.) that holds between collections whose extents (see extent) are exactly the same. (coExtensional COL1 COL2) means that COL1 and COL2 have all their elements in common: every instance of (see isa) one is an instance of the other. Note that since collections (see Collection), unlike mathematical sets (see Set-Mathematical), are \"intensionally defined\", two collections can be coextensional without thereby being identical (see equals). See also \ncoextensionalSetOrCollections."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(call_u_no_bc,"A KBDependentRelation (q.v.) and specialization of knownSentence (q.v.) that is used to state that a given CycLSentence-Assertible has been asserted in the KB (in some accessible Microtheory). More exactly, (call_u_no_bc SENT) is true in microtheory MT precisely when SENT canonicalizes into a set of clauses of the same form as the canonicalized form of some assertion in a microtheory accessible to MT. (The predicate is thus true both of assertions entered into the KB by hand and assertions deduced by Cyc from forward rules.) For the more specific claim that SENT is asserted in MT, see the predicate ist-Asserted.\n

\nThis predicate enables Cyc to select a subset of information when answering queries, filtering out more generic (inferrable-but-not-asserted) information. Thus, for example, the query:\n

\n(genls Dog Thing)\n

\nwill return True (in appropriate microtheories), whereas:\n

\n(call_u_no_bc (genls Dog Thing))\n

\nwill not."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arityMin,"A MetaRelation for specifying the minimum number\nof arguments a given VariableArityRelation must take if the resulting formula is to be semantically well-formed. (arityMin RELN N) means that semantic well-formedness requires that RELN take at least N arguments at a time. More precisely: a formula (RELN ARG1 ... ARGM) is semantically well-formed only if M is greater than or equal to N. For example, the minimum-arity of any instance of UnitOfMeasure is 1. Note that full semantic well-formedness requires obeying argument-type constraints (see ArgTypePredicate) as well as arity constraints. For a general explanation of semantic well-formedness, see CycLExpression-Assertible. See also arityMax and arity."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arityMax,"A MetaRelation for specifying the maximum number\nof arguments a given VariableArityRelation can take if the \nresulting formula is to be semantically well-formed. (arityMax RELN N) means \nthat semantic well-formedness requires that RELN take at most N arguments at \na time. More precisely: a formula (RELN ARG1 ... ARGM) is semantically \nwell-formed only if M is less than or equal to N. For example, the \nmaximum-arity of any instance of UnitOfMeasure is 2. Note that full semantic \nwell-formedness requires obeying argument-type constraints (see \nArgTypePredicate) as well as arity constraints. For a general explanation \nof semantic well-formedness, see CycLExpression-Assertible. See also \narityMin and arity."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arity,"A MetaRelation used for stating that a given relation takes a specified number of arguments. (arity RELN N) means that that semantic well-formedness requires that RELN take exactly N arguments at a time. That is, a formula (RELN ARG1 ... ARGM) is semantically well-formed only if M = N.\n

\nFor example, the arity of any instance of BinaryPredicate is 2.\n

\nNote that full semantic well-formedness requires obeying argument-type constraints (see ArgTypePredicate) as well as arity constraints. For a general explanation of semantic well-formedness, see CycLExpression-Assertible. See also CycLExpression-Askable."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(argSometimesIsa,"(argSometimesIsa RELATION POSITIVE-INTERGER-N COLLECTION) means that semantic\nwell-formedness requires that anything given as the Nth argument to RELN must be\nan instance of COL at sometime or other. More precisely, if (argSometimesIsa RELATION POSITIVE-INTERGER-N COLLECTION) then in order to assert: (RELATION ARG-N ... OTHER-ARGS), it must be the case that there exists some time interval, t, such that (isa ARG-N COLLECTION)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(argsIsa,"A binary ArgIsaPredicate (q.v.) that is used to put a specified isa based argument-type constraint on all of a given relation's argument-places at once. (argsIsa RELN COL) means that semantic well-formedness requires that each argument to which RELN is applied (regardless of argument-place) be an instance of COL. For example, '(argsIsa PlusFn ScalarInterval)' means that the function PlusFn must only be applied to scalar intervals. argsIsa is particularly useful for constraining (any and all of) the arguments to a VariableArityRelation (the preceding example being a case in point); though argsIsa may be applied to fixed-arity relations as well. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its immediate specializations. See also argsGenl."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(argsGenl,"A binary ArgGenlPredicate (q.v.) that is used to put \na specified genls based argument-type constraint on all of a given relation's \nargument-places at once. (argsGenl RELN COL) means that semantic well-formedness requires that each argument to which RELN is applied (regardless of argument-place) be an subcollection of COL. For example, `(argsGenl PerformSimultaneouslyFn Event)' means that the function PerformSimultaneouslyFn must only be applied to types of events. argsGenl is particularly useful for constraining (any and all of) the arguments to a VariableArityRelation (the preceding example being a case in point); though argsGenl may be applied to fixed-arity relations as well. For an explanation of semantic well-formedness, see CycLExpression-Assertible and its immediate specializations. See also argsIsa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(argAndRestIsa,"A ternary ArgIsaPredicate (q.v.) used to \nplace a specified isa based argument-type constraint on a given \nVariableArityRelation (q.v.) with respect to any of its argument-places \nwhose ordinal position is greater than or equal to a specified number.\n(argAndRestIsa RELN N COL) means that, as a necessary condition for \nsemantic well-formedness, anything given as the Nth or greater argument \nto RELN must be an instance of COL. Thus a closed formula\n(RELN ARG1..ARG(N)..ARG(N+1)..) is well-formed only if each of ARG(N)..ARG(N+1).. is an instance of COL. See also argsIsa and argAndRestGenl."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(argAndRestGenl,"A ternary ArgGenlPredicate (q.v.) used to \nplace a specified genls based argument-type constraint on a given \nVariableArityRelation (q.v.) with respect to any of its argument-places \nwhose ordinal position is greater than or equal to a specified number.\n(argAndRestGenl RELN N COL) means that, as a necessary condition for \nsemantic well-formedness, anything given as the Nth or greater argument \nto RELN must be an specialization of COL. Thus a closed formula \n(RELN ARG1..ARG(N)..ARG(N+1)..) is well-formed only if each of ARG(N)..ARG(N+1).. is an instance of COL. See also argsGenl and argAndRestIsa."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg6Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the sixth (or \"arg6\") argument-place of a given predicate. (arg6Format PRED FORMAT) means that PRED's arg6 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg5Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the fifth (or \"arg5\") argument-place of a given predicate. (arg5Format PRED FORMAT) means that PRED's arg5 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg4Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the fourth (or \"arg4\") argument-place of a given predicate. (arg4Format PRED FORMAT) means that PRED's arg4 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg3Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the third (or \"arg3\") argument-place of a given predicate. (arg3Format PRED FORMAT) means that PRED's arg3 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg2Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the second (or \"arg2\") argument-place of a given predicate. (arg2Format PRED FORMAT) means that PRED's arg2 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(arg1Format,"An instance of ArgFormatPredicate (q.v.) used to place a particular Format (q.v.) constraint on the first (or \"arg1\") argument-place of a given predicate. (arg1Format PRED FORMAT) means that PRED's arg1 is constrained to FORMAT. See the reified instances Format for\nfurther details."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(and,"A LogicalConnective that represents conjunction in CycL. It is a VariableArityRelation, taking an arbitrary number of ELSentence-Assertibles as arguments. (and P Q ... Z) is true if and only if all of the sentences P, Q, ..., and Z are true."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(abnormal,"A binary MetaKnowledgePredicate that is used to state exceptions to a given general CycLAssertion. Typically, an abnormal assertion will be the result of the CycCanonicalizer having \"transformed\" a sentence asserted at the EL level that was built from an ExceptionPredicate (i.e. exceptWhen or exceptFor). While perhaps less common-sensically intuitive than exceptWhen or exceptFor, abnormal facilitates an efficient and uniform handling of exceptions.\n

\nHere, in more detail, is how abnormal is used. Every default rule in our system, schematically:\n

\nP[X1 ... Xn] -> Q[X1 ... Xn]\n

\n(with X1, ..., Xn free in both P and Q) is implicitly treated as\n

\n(not (\"abnormal-for-this-rule\" X1 ... Xn)) & (P[X1 ... Xn] -> Q[X1 ... Xn]) .\n

\nThus rules without exceptions need never incur the overhead of default reasoning. Since a different \"abnormality\" relation would otherwise be needed for every default rule in the system, we use instead a single predicate -- abnormal -- which takes the rule in question as an argument. And the other argument to abnormal is a List of variables (or of a single closed term) over which abnormality is computed; this allows abnormal to be binary rather than variable-arity. Hence a sentence of the form\n

\n(exceptWhen EXCEPTION RULE) ,\n

\nin which each of the variables X1, ..., Xn occurs free in both EXCEPTION and RULE, gets canonicalized to an implies rule that concludes to an abnormal sentence:\n

\n

\n(implies\n  EXCEPTION\n  (abnormal (TheList X1 .... Xn) RULE)) .\n
\n

\nAnd a sentence of the form\n

\n(exceptFor TERM RULE) ,\n

\nin which exactly one variable X occurs free in RULE, gets canonicalized to a sentence of the form\n

\n(abnormal (TheList TERM) RULE) .\n

\nSee also pragmaticallyNormal."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtVariableAritySkolemFunction,"The subcollection of SkolemFunctions with variable arity. These are only created when a sequence variable is in the scope of the skolem."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(cycVariableAritySkolemFuncN,"The subcollection of SkolemFuncNs with variable arity. These are only created when a sequence variable is in the scope of a bounded existential."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtVariableArityRelation,"A specialization of Relation. Each instance of VariableArityRelation is a relation that can take a variable number of arguments. The degree of variability for a given such relation can be constrained using the predicates arityMin and arityMax. Examples of VariableArityRelations include the predicate different and the function PlusFn. Thus the terms '(PlusFn 1 2)' and '(PlusFn 1 2 3)' are both well-formed. Cf. FixedArityRelation."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtUnreifiableFunction,"A specialization of Function-Denotational instances of which are such that their values are not reified in the Cyc system. More precisely, an instance of UnreifiableFunction is such that closed \"NATs\" (see CycLNonAtomicTerm) built from its standard CycL name are _not_ instances of HLReifiedDenotationalTerm. Constrast with ReifiableFunction. Usually it is more efficient to make functions reifiable; but it is not desirable to reify every non-atomic term, such as those built from (names of) instances of FunctionFromQuantitiesToQuantities. For example, it would be cumbersome to reify every term of the form (Inch N) that happened to appear in a CycL assertion."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vUnityFn,"An instance of ZeroDimensionalUnitOfMeasure (q.v.) that takes one or two numbers or other NumericIntervals (q.v.) as argument(s) and returns the continuous numeric-interval that spans between and includes those arguments. Given one argument, Unity behaves like an identity function.\n

\nMore precisely: for any numeric-interval NUM, (Unity NUM) = NUM; and for any two numeric-intervals LO and HI such that (greaterThanOrEqualTo HI LO), (Unity LO HI) is the numeric-interval that ranges from the least point-value (see Number-General) subsumed by (see quantitySubsumes) LO to the greatest point-value subsumed by HI.\n

\nIn practice, LO and HI will typically be two distinct RealNumbers, and (Unity LO HI) will be the continuous ProperIntervalOnNumberLine that ranges from LO to HI. For example, (Unity 1 10) is the interval from 1 to 10 inclusive. But note that LO and/or HI might themselves be proper intervals: (Unity (Unity 7 9) 11) is thus the interval from 7 to 11 inclusive.\n

\nUnity is classified as a UnitOfMeasure mainly in order to simplify the application of quasi-mathematical operations (e.g. PerFn, UnitProductFn) to units-of-measure generally. For example, TimesPerDay is defined as the result of \"dividing\" (via PerFn) Unity by DaysDuration."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(cycUnitProductFn,"A binary UnitOfMeasureDenotingFunction that takes two UnitOfMeasure (q.v.) functions and returns the unit-of-measure function whose value for any given argument is the multiplicative \"product\" of the respective values yielded by the first two units, when one unit is applied to that same argument and the other unit is applied to 1. That is, (UnitProductFn UNIT1 UNIT2) is the function PRODUCT-FN such that, for any number or other NumericInterval NUM, (PRODUCT-FN NUM) = (TimesFn (UNIT1 NUM) (UNIT2 1)).\n

\nFor example, (UnitProductFn Meter Meter) is SquareMeter; and (e.g.) (SquareMeter 5) is equal to (TimesFn (Meter 5) (Meter 1)). Also, (UnitProductFn Kilowatt HoursDuration) is KilowattHour.\n

\nSee also PerFn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ttUnitOfMeasure,"A specialization of ScalarDenotingFunction (q.v.). Each instance of UnitOfMeasure is a function that takes one or two numbers or other NumericIntervals as arguments, and returns as value a MeasurableQuantity (q.v.), such as a Distance or a Speed or a Volume. If a unit of measure is applied to one number (see Number-General) the result is a precise quantity that is a ScalarPointValue; if applied to two (different) numbers -- or to one (or two) ProperIntervalOnNumberLine(s) -- the result is a closed-interval quantity that is a ScalarProperInterval. For example, (Meter 5) is the distance five meters and (Meter 5 10) is the distance \"five to ten meters (inclusive)\".\n

\n(A partial exception to the above is the unit-of-measure Unity (q.v.), which always returns a NumericInterval rather than a MeasurableQuantity.)\n

\nSpecializations of UnitOfMeasure grouped by what they measure include UnitOfTime, UnitOfSpeed, and UnitOfVolume. Other specializations are OneDimensionalUnitOfMeasure, MultiDimensionalUnitOfMeasure, UnitOfMeasureWithPrefix and UnitOfMeasureNoPrefix."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtUnaryPredicate,"A specialization of both UnaryRelation and Predicate. UnaryPredicate is the collection of all predicates whose arity (see arity) is 1."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtUnaryFunction,"A specialization of both FixedArityFunction and UnaryRelation (qq.v.). Each instance of UnaryFunction is a function that always takes a single argument, i.e. has an arity (see arity) of 1."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtTruthFunction,"A major subcollection of Relation that subsumes the collections Predicate, LogicalConnective, and Quantifier (qq.v.). Truth-functions, or rather the expressions that represent or denote them, are used to form sentences. More precisely, any CycL expression that denotes an instance of TruthFunction (and only such an expression) can appear in the \"0th\" argument-position (i.e. as the term immediately following the opening parenthesis) of a CycLSentence. \n

\nThe name 'TruthFunction' derives in part from the fact that the sentences thus formed (if semantically well-formed and quantificationally closed; see CycLSentence-Assertible and CycLClosedSentence) are the kind of expression that can be true or false (with respect to a given context and interpretation). Though not really functions (cf. Function-Denotational), many TruthFunctions are \"truth-functional\" in the sense that the truth-value of a (closed, semantically well-formed) sentence (RELN ARG1..ARGN) built using a truth-function RELN is uniquely determined (with respect to a given context) by RELN together with the argument(s) ARG1..ARGN to which it is applied. For example, the sentence (mother ChelseaClinton HillaryClinton) is made true (in the actual world) by the fact that Chelsea Clinton's mother is Hillary Clinton."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtTransitiveBinaryPredicate,"A BinaryPredicateTypeByLogicalFeature and thus a specialization of BinaryPredicate. A binary predicate PRED is an instance of TransitiveBinaryPredicate only if it has the following property: For any THING1, THING2, and THING3, if both of these hold:\n

\n  (PRED THING1 THING2)\n  (PRED THING2 THING3)\n
\nThen so does this:\n
\n  (PRED THING1 THING3) .\n
\nNote that a necessary condition on PRED's being transitive is that its two argument-places must be co-satisfiable; see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement.\n

\nInstances of TransitiveBinaryPredicate include greaterThan,\ngeographicalSubRegions, and cotemporal. \n

\nCf. QuasiTransitiveBinaryPredicate and AntiTransitiveBinaryPredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(xTLVariableFn,"Denotes HL variables at the TL: arg1 is the HL index of the variable; arg2 is the EL string name of the variable."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(xTLReifiedNatFn,"Denotes a reified nat term at the TL: arg1 is the formula of the nat."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(xTLAssertionFn,"Denotes HL assertion terms at the TL (e.g., assertions appearing as terms within meta-assertions): arg1 is the mt of the assertion; arg2 is the formula of the assertion."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vTimesFn,"A VariableArityRelation that represents multiplication in CycL. (TimesFn MULT1 MULT2 ...) yields a quantity which is the result of multiplying MULT1 MULT2 (...) together. All arguments to TimesFn must be instances of ScalarInterval, as is its result. Thus (TimesFn 2 3 4) returns 24; (TimesFn Pi-Number E-LogarithmBase) returns pi times e. For division see QuotientFn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tThing,"Thing is the \"universal collection\": the collection which, by definition, contains everything there is. Every thing in the Cyc ontology -- every Individual (of any kind), every Set-Mathematical, and every Collection -- is an instance of (see isa) Thing. Similarly, every collection is a subcollection of (see genls) Thing. Trivially, Thing is both an instance of and a subcollection of itself, and is not a subcollection of any other collection. (Note that the above reference to \"every thing in the Cyc ontology\" is not meant to be limited to things actually reified in the Cyc system, but includes (e.g.) every instance -- reified or not, known or not -- of every collection recognized by Cyc.)"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftTheTerm,"A special kind of term that allows back-reference to any individual thing that satisfies the constraints on the TheTerm. E.g., 'Suppose a cat walks into a fish store. The cat is likely to get into a lot of trouble.' 'The cat' in the second sentence refers back to 'a cat' in the first; i.e., any cat that walks into a fish store. In Cyc, the constraints for a TheTerm in a given context are given by use of the predicate theTermConstraints on the unit representing that context. In lifting assertions out of that context, the constraints are added as antecedents."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tSetOfTheSetOfFn,"A binary SetDenotingFunction and ScopingRelation that takes a variable and an open sentence to a set, where the open sentence specifies a necessary and sufficient membership condition for the set. If SENT is an open CycLSentence-Assertible in which VAR is the only variable occuring free, (TheSetOf VAR SENT) is the Set-Mathematical of exactly those things that satisfy SENT. For example, (TheSetOf ?X (and (isa ?X Dog) (mainColorOfObject ?X BlackColor))) is the set of black dogs.\n

\nNote that if VAR does not occur free in SENT, or is not the only variable occuring free in SENT, the term (TheSetOf VAR SENT) will be itself be open (see CycLOpenNonAtomicTerm) and thus will not denote anything. Given that a true sentence is satisfied by everything, we stipulate that (TheSetOf VAR SENT) is undefined whenever SENT is closed in order to avoid commitment to a \"universal set\". \n

\nSee also TheSet, which is used to specify a set by enumerating its elements. And see TheCollectionOf."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tSetOfTheSetFn,"A variable-arity SetDenotingFunction that is used to specify a set by enumerating its elements. For any finite sequence THING1,...,THINGN (N >= 1), (TheSet THING1...THINGN) is the Set-Mathematical whose elements (see elementOf) are precisely THING1,...,THINGN. For example, (TheSet SonnyBono Cher) is the set whose only elements are Sonny and Cher. \n

\nNote that in the degenerate case where N is zero, (TheSet) is TheEmptySet. \n

\nSee also the related function TheSetOf, which is used to specify a set by giving a necessary and sufficient membership condition. And see TheList and TheCollection."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vTheListFn,"TheList is a function that combines its arguments into a list. For any ITEM(1), ..., ITEM(n), each of which is an instance of Thing, (TheList ITEM(1) ... ITEM(n)) gives the instance of List-Extensional whose first member is ITEM (1), ..., and whose last member is ITEM(n). Note that in general ITEM(1), ..., ITEM(n) do not have to be distinct, though they do if (TheList ITEM(1) ... ITEM(n)) is an instance of ListWithoutRepetition."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(iTheEmptySet,"TheEmptySet is the empty (or \"null\") set: the unique set that has no elements. Note that TheEmptySet is an instance of Set-Mathematical and thus _not_ an instance of Collection."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vTheEmptyList,"An instance of ListWithoutRepetition. TheEmptyList is a list that has no members (see listMembers). Note that any list that has no members is identical with TheEmptyList; thus TheEmptyList is the only list whose length is 0. Note also that TheEmptyList is a sublist (see subLists) of every list. Note finally that TheEmptyList is not the same as TheEmptySet (q.v.)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtTernaryPredicate,"A specialization of both TernaryRelation and Predicate. TernaryPredicate is the collection of all predicates whose arity (see arity) is 3."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtTernaryFunction,"A specialization of FixedArityFunction and TernaryRelation. An instance FUNC of FixedArityFunction is an instance of TernaryFunction if and only if FUNC has an arity of three."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtSymmetricBinaryPredicate,"A specialization of both BinaryPredicate and CommutativeRelation (qq.v.). A binary predicate PRED is an instance of SymmetricBinaryPredicate if and only if (i) for any things X and Y, if (PRED X Y) then (PRED Y X) and (ii) the single-argument argument type constraints (see argIsa and argGenls) on PRED's two argument-places are co-satisfiable (see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement). Note that if PRED satisfies condition (i), then it also satisfies condition (ii) as long as (PRED A B) holds for some A and B.\n

\nInstances of SymmetricBinaryPredicate include siblings, teammates, connectedTo, and bordersOn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftSymbol,"The collection of all SubLAtoms that are also \"symbols\" in the SubL language. That is, each instance of SubLSymbol satisfies the defnIff SYMBOLP. Note that `symbol' has a very specific, technical meaning in SubL. Save for those that are variables (see SubLVariable), SubLSymbols are rarely used in CycL assertions, except within those built with certain CycInferenceDescriptorPredicates like defnIff. Examples of SubL symbols include the symbols 'GENLS' and 'CYC-SYSTEM-NON-VARIABLE-SYMBOL-P'. Note also that SubLSymbol is a \"quoted-collection\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftString,"A subcollection of SubLAtomicTerm (q.v.) whose instances can be used to denote character-strings. In the SubL language (as in English), one can refer to a particular character-string by simply putting a pair of quotation marks around it. Semantically, what this amounts to is using a certain character-string to denote itself. \n

\nMore precisely: a given SubLString STRING is a character-string such that, when it appears inside a pair of double-quotation marks, STRING is interpreted as denoting itself (i.e. STRING). The surrounding quotation-marks are not considered to be parts of STRING; rather, they are syncategorematic symbols whose role is merely to indicate that a string is being referred to. Thus, in the context of the sentence '(firstName Lenat \"Doug\")', the four-character string 'Doug' denotes itself: the string `Doug'. \n

\nNote that not every CharacterString is a SubLString: there are some restrictions on what characters a SubL-string can contain. Note also that SubLStrings are atomic terms (see SubLAtomicTerm and CycLAtomicTerm), as they cannot be constructed out of other SubL (or CycL) terms via the syntax (grammar) of SubL (or CycL). Thus although the string 'hotdog' can indeed be obtained from 'hot' and 'dog' via concatenation (see ConcatenateStringsFn), the syntax of SubL (or CycL) itself contains no rule that licenses such a construction (see e.g. the comments on SubLSExpression, CycLExpression, CycLTerm, CycLFormula, and various subcollections thereof). Note finally that SubLString is a \"quoted-collection\" (see quotedCollection). Thus the sentence '(isa \"hotdog\" SubLString)' means, just as one would expect, that the six-character string 'hotdog' (not the eight-character quote-inclusive '\"hotdog\"'; see above) is an instance of SubLString."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftSubLSExpression,"The collection of all expressions of the SubL language. SubL is the implementation language of the Cyc system, and it subsumes the CycL language. The CycL grammar is more strict than the SubL grammar. Thus, while every CycLExpression is a SubLSExpression, the converse is not true. Examples of SubLSExpressions that are not CycLExpressions include Arabic decimal numeric expressions such as '123', expressions like '(1 2 3)' that denote lists of numbers, and \"dotted pair\" expressions like '(Cat . Dog)'."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftRealNumber,"The collection of all number-denoting expressions in the CycL language that are _not_ CycL constants or NATs, but are terms of SubL, the underlying implementation language of the Cyc system. SubLRealNumbers are numeric strings of the Arabic decimal system, including the decimal point and scientific notation. Examples include the terms `212' and `3.14159d0'. Non-examples include the expressions `One', `(Meter 6)', `(Unity 3)', `:34', `PlusInfinity', and `Avogadro's number'. Note that this collection, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftPositiveInteger,"The collection of all positive-integer-denoting expressions in the CycL language that are not CycL constants or NATs, but are terms of SubL, the underlying implementation language of the Cyc system. SubLPositiveIntegers are numeric strings of the Arabic decimal system (not including the decimal point or scientific notation). Examples include the expressions '2', '12', and '4'. Non-examples include '0', '4.012', '(Meter 6)', '(Unity 3.3)', ':34', and 'PlusInfinity'. Note that SubLPositiveInteger is a \"quoted-collection\" (see quotedCollection); thus the sentence '(isa 12 SubLPositiveInteger)' means that the expression '12' (not the number 12) is an instance of SubLPositiveInteger."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftNonVariableSymbol,"The collection of all SubLSymbols except SubLVariables (qq.v.); a subcollection of CycLClosedAtomicTerm. Note that `symbol' has a very specific, technical meaning in SubL; SubLNonVariableSymbols are rarely used in CycL assertions, except within those built with certain CycInferenceDescriptorPredicates like defnIff and those whose arguments are KeywordVariableTemplates (qq.v.). Examples of SubL non-variable symbols include the symbols `GENLS', `:ARG1', and `CYC-SYSTEM-NON-VARIABLE-SYMBOL-P'. Note that this collection, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftNonVariableNonKeywordSymbol,"The collection of all SubLSymbols except SubLVariables (q.v.) and SubLKeywords (q.v.); a subcollection of CycLClosedAtomicTerm. Note that `symbol' has a very specific, technical meaning in SubL; SubLNonVariableNonKeywordSymbols are rarely used in CycL assertions, except within those built with certain CycInferenceDescriptorPredicates like defnIff. Examples of SubL non-variable non-keyword symbols include the symbols `GENLS' and `CYC-SYSTEM-NON-VARIABLE-NON-KEYWORD-SYMBOL-P'. Note that this collection, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftNonNegativeInteger,"The collection of all non-negative-integer-denoting expressions in the CycL language that are _not_ CycL constants or NATs, but are terms of SubL, the underlying implementation language of the Cyc system. SubLNonNegativeIntegers \nare numeric strings of the Arabic decimal system (not including the decimal point or scientific notation). Examples include the expressions `0', `12', and `4'. Non-examples include `4.012', `(Meter 6)', `(Unity 3.3)', `:34', and `PlusInfinity'. Note that SubLNonNegativeInteger is a \"quoted-collection\" (see quotedCollection); thus the sentence `(isa 12 SubLNonNegativeInteger)' means that the expression `12' (and not \nthe number 12) is an instance of SubLNonNegativeInteger."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftList,"A collection of list-denoting expressions that are not represented in CycL (i.e. they are not CycLConstants or CycLNonAtomicTerms) but are represented in SubL, the underlying implementation language of the Cyc system. Each instance of SubLList is a sequence of SubLListOrAtoms (q.v.) enclosed in parentheses. SubL lists are those things that pass the defnIff LISTP. Note that this collection is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftKeyword,"The subcollection of SubLSymbol consisting of all SubL keywords. Instances include the symbols `:KEYWORD', `:OBJECT', and `:PLURAL'. Every instance of SubLKeyword satisfies (in the sense relevant to defnIff) `KEYWORDP'. Note that SubLKeyword, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftInt,"The collection of all integer-denoting expressions in the CycL language that are _not_ CycL constants or NATs, but are terms of SubL, the underlying implementation language of the Cyc system. SubLIntegers are numeric strings of the Arabic decimal system (including the negative-value symbol `-', but _not_ the decimal point or scientific notation) that denote integers. Examples include the expressions `0', `12', and `-4' (which denote the integers 0, 12, and -4, respectively). Non-examples include `4.012', `(Meter 6)', `(Unity 3.3)', `:34', and `PlusInfinity'. Note that SubLInteger is a \"quoted-collection\" (see quotedCollection). Thus the sentence `(isa 12 SubLInteger)' means that the expression `12' (and not the number 12) is an instance of SubLInteger. Similarly, the assertion `(genls SubLInteger Integer)' means (not that each SubL integer is an integer, but) that each instance of SubLInteger _denotes_ an instance of Integer (see the shared NoteAboutUseVersusMention)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftCharacter,"The collection of all character-denoting terms in the CycL language that are SubLAtomicTerms (q.v.). (SubL, which subsumes CycL, is the underlying implementation language of the Cyc system.) A given SubLCharacter CHAR-TERM is itself a string consisting of the hash-symbol (`#'), followed by the backslash (`\\'), followed (in most cases) by the character CHAR that CHAR-TERM denotes. For example, the SubLCharacter `#\\A'\ndenotes the character `A'. (An exception to the above is when CHAR is a non-printing or control character, in which case a specially-designated string\nappears after the `#\\'.)"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftAtomicTerm,"The collection of all atomic denotational terms in the CycL language that are not explicitly represented in CycL (i.e. they are neither CycLConstants nor CycLVariables) but are represented in SubL, the underlying implementation language of the Cyc system. \"Atomic\" here means not constructable from other terms via the SubL syntax. Examples include the terms '212', ':NOUN', '#x', and 'VARIABLE-P'. Do not confuse this collection with SubLAtom, most of whose instances, while they are expressions of SubL, are not part of CycL. Note that this collection, like most instances of CycLExpressionType, is \"quoted\"."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftAtom,"A collection of SubLExpressions that are atomic: they cannot be decomposed into other SubL expressions. Save for certain variables (see SubLVariable), instances of SubLAtom are rarely used in CycL assertions (other than assertions built with certain CycInferenceDescriptorPredicates like defnIff). Many SubL atoms are not even CycLExpressions. Do not confuse this collection with SubLAtomicTerm, which is a CycLExpressionType (though its instances are neither CycL constants nor CycL variables). Note that SubLAtom is a \"quoted-collection\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(iSkolemFunctionFn,"SkolemFunctionFn is used by the CycCanonicalizer and should rarely (if ever) need to be seen by users or referenced in assertions entered at the EL level. It is used by the canonicalizer to denote a skolem function before it is reified, when the skolem is derived from a formula asserted at the EL level that uses thereExists. Its arity is 3: the first argument is a list of the term variable arguments of the denoted skolem function, (term variables which are in the scope of the existential), the second argument is a variable which uniquely identifies the existentially quantified variable by which the denoted skolem will be represented in the canonical version of the formula, and the third is a sequence variable if there is a sequence variable argument of the denoted skolem function (which there will be iff there is a sequence variable in the scope of the existential), and NIL otherwise."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtSkolemFunction,"A specialization of IndeterminateTermDenotingFunction and ReifiableFunction (qq.v.). SkolemFunction is a collection of system-generated functions that implement existential quantification in Cyc. Whenever someone asserts to the Knowledge Base a sentence that contains 'thereExists' (in an arg0 position), Cyc automatically creates a new instance of SkolemFunction and rewrites the assertion using that Skolem function.\n

\nFor example, suppose we want Cyc to know that every animal has a birth date. So we assert the following sentence:\n

\n

\n  (implies\n    (isa ?X Animal)\n    (thereExists ?Y\n      (birthDate ?X ?Y))) .\n
\n

\nIn response, Cyc automatically reifies a new unary instance of SkolemFunction (call it 'BirthDateFn') that takes any given animal to its date of birth, and then rewrites our rule using BirthDateFn instead of thereExists, as\n

\n

\n  (implies\n    (and\n      (isa ?X Animal)\n      (termOfUnit ?Y (BirthDateFn ?X)))\n    (birthDate ?X ?Y)) .\n
\n

\nNote that actual Cyc-generated Skolem function names currently (02/04) consist of the prefix 'SKF-' follow by a numeral."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(fSkolemFuncNFn,"SkolemFuncNFn is used by the CycCanonicalizer and should rarely\n(if ever) need to be seen by users or referenced in assertions entered\nat the EL level. It is used by the canonicalizer to denote a skolem\nfunction before it is reified, when the skolem is derived from a formula\nasserted at the EL level that uses thereExistAtLeast,\nthereExistAtMost, or thereExistExactly. Its arity is 4: the first\nargument is a list of the term variable arguments of the denoted skolem function,\n(term variables which are in the scope of the bounded existential).\nThe second argument is a variable which uniquely identifies the\nexistentially quantified variable by which the denoted skolem will\nbe represented in the canonical version of the formula.\nThe third is a sequence variable if there is a sequence variable\nargument of the denoted skolem function (which there will be iff there\nis a sequence variable in the scope of the bounded existential), and NIL otherwise.\nThe fourth is an interval specifying the number of things which may satisfy the formula."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(cycSkolemFuncN,"SkolemFuncN is a collection of Cyc system-generated functions that partially implement existential quantifications in Cyc. Whenever someone asserts to Cyc an expression that contains a 'thereExistAtLeast', a 'thereExistAtMost', or a 'thereExistExactly' quantifier, Cyc automatically creates a new instance of SkolemFuncN and rewrites the assertion using this skolem function instead of that existential quantifier. See also termOfUnit. At this time (3/98), skolem functions are automatically named by the Cyc system using the prefix 'SKF-' followed by a number."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tSet,"A KBDependentCollection of collections of collections (and thus an instance of CollectionTypeType and a specialization of CollectionType). A sibling-disjoint collection type is such that its known (i.e. KB-represented) instances are collections that -- save for any that are related to each other by genls and any that are explicitly asserted to be exceptions (see siblingDisjointExceptions) -- are disjoint from each other. \n

\nMore precisely, each instance SIB of SiblingDisjointCollectionType is a collection of collections that has the following KB-dependent property: \n

\nFor any two known instances COL1 and COL2 of SIB, at least one of the following is known to hold: \n

\n  (a) (genls COL1 COL2)\n  (b) (genls COL2 COL1)\n  (c) (siblingDisjointExceptions COL1 COL2)\n  (d) (disjointWith COL1 COL2)\n
\nMoreover, note that if MT is a context (see Microtheory) in which (i) both (isa COL1 SIB) and (isa COL2 SIB) hold and (ii) neither (genls COL1 COL2) nor (genls COL2 COL1) nor (siblingDisjointExceptions COL1 COL2) is known to hold (see knownSentence), then \n(disjointWith COL1 COL2) holds by default in MT. \n

\nFor example, in BiologyMt both Person and Dog are instances of the sibling-disjoint collection type BiologicalSpecies, while neither (genls Person Dog) nor (genls Dog Person) nor (siblingDisjointExceptions Person Dog) is known to hold in that context; consequently, (disjointWith Person Dog) holds by default in BiologyMt. Instances of SiblingDisjointCollectionType include BiologicalTaxon (and its specializations), OrganismPartType, and RelationshipTypeByArity.\n

\nSee the generalization SiblingDisjointSetOrCollectionType. Also cf. the stronger notion of DisjointCollectionType."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ttSiblingDisjointAttributeType,"A collection of collections. Each instance of SiblingDisjointAttributeType is a collection of quantities. If COL is such a collection, then nothing can have two instances of COL as quantities unless those two instances are related in a quantitySubsumes relationship to each other. See also SiblingDisjointCollectionType."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ttSetOrCollection,"A specialization of MathematicalThing. Something is an instance of SetOrCollection just in case it is a collection (i.e. an instance of Collection) or a mathematical set (i.e. an instance of Set-Mathematical). Instances of Set-Mathematical and instances of Collection (and thus instances of SetOrCollection) share some basic common features. All instances of Collection and all instances of Set-Mathematical (and thus all instances of SetOrCollection) are abstract entities, lacking spatial and temporal properties. Nearly all instances of Collection (except \"empty\" collections) and nearly all instances of Set-Mathematical (except the empty set; see TheEmptySet) have \"elements\" (i.e. instances or members; see elementOf); hence set-or-collections may stand to one another in generalized set-theoretic relations such as subsetOf and disjointWith (qq.v.). (It is this shared feature of having elements that provides the basic rationale for reifying the collection SetOrCollection.) Nevertheless, sets and collections differ in two important ways. First, each collection is intrinsically associated with an intensional criterion for membership -- a more or less natural property (or group of properties) possessed by all of (and only) its elements. Collections are thus akin to kinds. In contrast, the elements of a set are not required to be homogeneous in any respect: any things whatsoever may together constitute the elements of a set. The second major difference between sets and collections is that no two distinct sets can be coextensional (i.e. have exactly the same elements; see coExtensional). Sets can thus be identified purely on the basis of their extensions (see extent). Collections, on the other hand, are individuated by their intensional criteria for membership. So collections that have exactly the same elements might nevertheless be distinct, differing in their respective membership criteria. (Note that the general relationship between collections and their \"intensional criteria for membership\" in the above sense is not something that is currently represented explicitly in the Knowledge Base (though this seems a worthwhile area for future work); still the comment and other \"definitional\" assertions on a given collection should ideally convey a reasonably clear and precise idea of its associated membership criterion.)"),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tSetMathematical,"A specialization of SetOrCollection (q.v.); the collection of mathematical sets. An instance of Set-Mathematical can be any arbitrary set of Things. A good way to explain this notion with respect to the Cyc ontology is to contrast Set-Mathematical with Collection (q.v.). First, while the instances of a given collection all have some more-or-less significant (often \"natural\") property or properties in common, the elements (see elementOf) in a given set might have nothing in common (besides membership in that set). Second, while it is in principle possible for two distinct collections to have exactly the same elements (with respect to a given context), this cannot happen in the case of sets, which are individuated strictly in terms of their extensions (see extent). Third (and specifically regarding their expression in the CycL language), unlike with collections, rarely will it be desirable to create a new constant to denote a particular set. Instead, a set will often be either (a) intensionally specified by a defining property via TheSetOf (q.v.), as in `(TheSetOf ?X (and (isa ?X Integer) (greaterThan ?X 42)))', or (b) extensionally specified by enumerating its elements via TheSet (q.v.), as in `(TheSet 3 4 5)'; see also ThePartition and TheCovering."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vSeptember,"A specialization of CalendarMonth. Each instance of September is the ninth month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtSententialRelation,"A collection of mathematical objects. Each instance of SententialRelation is by definition either a LogicalConnective or a Quantifier."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtScopingRelation,"A specialization of Relation whose instances are used to determine a \"scope\" with respect to one or more variables and to bind any free occurrences of those variables that are inside that scope. Each instance of ScopingRelation takes as its arguments (at least) a variable or list of variables (see CycLVariable and CycLVariableList) and a formula (see CycLExpression-Assertible). The former argument is the scoping relation's \"scoping\" argument (see scopingArg), and the latter its \"scoped formula\" argument (see scopedFormulaArg).\n

\nSyntactically, the formula (SCOPINGRELN VAR SENT) might either be a sentence or a non-atomic term (see CycLNonAtomicTerm), depending on which ScopingRelation it is built from. Suppose for simplicity that the sentence SENT itself contains no ScopingRelation expressions, so that any variables occurring in SENT are not bound (i.e. they are _free_). Then, in the formula (SCOPINGRELN VAR SENT), the _scope_ of the occurrence of the term SCOPINGRELN is SENT, and any free occurrence of the variable VAR in SENT is said to be _bound_ by that occurrence of SCOPINGRELN, and thus is bound (and hence not free) with respect to the entire formula. (The occurrence of VAR immediately to the right of SCOPINGRELN is also considered bound with respect to the entire formula.)\n

\nSemantically, if the formula (SCOPINGRELN VAR SENT) is _closed_ (i.e. if it contains no free occurrence of any variable), then it will in some sense be \"about\" the value(s) of VAR that satisfy SENT. That is, if (SCOPINGRELN VAR SENT) is a closed sentence it will state something about those values, while if (SCOPINGRELN VAR SENT) is a closed NAT it will (purport to) denote something related to those values. For an example of the former case see thereExists; for the latter case see TheSetOf. (If there are no free occurrences of VAR inside SENT, then (SCOPINGRELN VAR SENT) is a \"vacuous\" application of SCOPINGRELN that means exactly what SENT means.)\n

\nInstances of ScopingRelation include all of the Quantifiers and Lambda."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vtScalarPointValue,"A specialization of ScalarInterval (q.v.). Each instance of ScalarPointValue is a specific number or quantity, as opposed to a range of numbers or quantities (cf. ScalarProperInterval). Instances of ScalarPointValue include all reals numbers and other Number-Generals (q.v.), as well as specific instances of Quantity such as (Meter 3) and (SecondsDuration 10)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vRoundUpFn,"An instance of EvaluatableFunction. When applied to an instance INTERVAL of ScalarInterval, RoundUpFn returns an instance ROUNDED-INTERVAL of ScalarInterval in which the minimum and maximum ranges of INTERVAL have been rounded upwards to integer values. For example, (RoundUpFn (Meter 2.5 5.2)) is (Meter 3 6)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vRoundDownFn,"(RoundDownFn QUANTITY) converts QUANTITY into one where the maximum and minimum ranges have been rounded downwards to integer values. For example, (RoundDownFn (Meter 2.5)) denotes (Meter 2)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vRoundClosestFn,"(RoundClosestFn QUANTITY) converts QUANTITY into one where the maximum and minimum ranges have been rounded to the closest integer values. For example, (RoundClosestFn (Meter 2.41)) denotes (Meter 2), (RoundClosestFn (Meter 2.7)) denotes (Meter 3), and (RoundClosestFn (Meter 1.6 4.2)) denotes (Meter 2 4). If QUANTITY is exactly between two integers (that is, in the form integer+0.5), then it is rounded to the one that is even. So, (RoundClosestFn (Meter 2.5)) denotes (Meter 2), and (RoundClosestFn (Meter 7.5)) denotes (Meter 8). See also RoundUpFn, RoundDownFn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tRelation,"A specialization of MathematicalObject and the collection of all relations. Each instance of Relation is a relation that can hold among one or more things, depending on whether the relation is unary, binary, ternary, or whatever (see arity and relationalArity). A unary relation (such as unknownSentence) is a sort of degenerate case that holds of certain individual things (in this case, all sentences that are unknown to Cyc). A binary relation (such as likesAsFriend) relates one thing to another (in this case, it relates one sentient animal to another just in case the first likes the second). A ternary relation relates certain triples of things. And so on. There are also relations of no particular fixed arity; see VariableArityRelation.\n

\nNames of relations can be used to construct sentences and other formulas. More precisely, CycL terms that denote Relations can appear in the \"0th\" argument (or \"arg0\") position of a CycLFormula (q.v.), i.e. as the term immediately following the formula's opening parenthesis.\n

\nAn important subcollection of Relation is TruthFunction (q.v.), whose instances are intimately related to truth-values, as reflected in the fact that the CycL expressions that denote truth-functions can appear in the arg0 position of a CycLSentence; and a sentence (if quantificationally closed; see CycLClosedSentence), will generally be either true or false (with respect to a given context or interpretation). The major subcollections of TruthFunction are Predicate, LogicalConnective, and Quantifier (qq.v.).\n

\nAnother important subcollection of Relation is Function-Denotational (q.v.), the collection of all functions. A CycL term that denotes a function can appear in the arg0 position of a CycLNonAtomicTerm (q.v.).\n

\nSee also relationExtension and relationHoldsAmong."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtReifiableFunction,"A specialization of Function-Denotational. Each instance of ReifiableFunction is denoted by a CycL constant that can stand in the 0th (or \"arg0\") position in a CycLReifiableNonAtomicTerm (q.v.). For example, GovernmentFn is a reifiable function, so the term `(GovernmentFn France)' is a reifiable non-atomic term (or \"NAT\"). And since this particular term actually _is_ reified in the Cyc Knowledge Base, it is, more specifically, a CycLNonAtomicReifiedTerm (or \"NART\"). The NART `(GovernmentFn France)' is treated more or less the same as if it were a CycL constant (named, say, `GovernmentOfFrance'). Similary, the constant for GovernmentFn can be applied to the constant (or other reified or reifiable term) for _any_ instance of GeopoliticalEntity to form a reifiable NAT that denotes that region's government; and should this NAT appear in a sentence that is asserted to the KB, it will thereby become a NART. Note, however, that not all NATs are such that it is desireable that they should become reified (i.e. become NARTs) if they appear in assertions; for more on this see UnreifiableFunction."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtReflexiveBinaryPredicate,"The specialization of BinaryPredicate whose instances are reflexive relations. A reflexive binary predicate relates anything that meets the predicate's argument constraints to that thing itself. Typically, a reflexive predicate has precisely the same constraints on both of its argument-places.\n

\nMore precisely: a binary predicate PRED is an instance of ReflexiveBinaryPredicate if and only if both (i) for every X that satisfies the constraints on (i.e is an admittedArgument for) both argument-places of PRED, (PRED X X) holds and (ii) PRED's two argument-places are \"co-satisfiable\" with respect to their (single-argument) type constraints (see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement).\n

\nInstances of ReflexiveBinaryPredicate include physicalParts, inRegion, genls, and equals."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftRealNumber,"The collection of real numbers; a specialization of both IntervalOnNumberLine and ScalarPointValue (qq.v.). Each instance of RealNumber is a single point on the real number line, which has no upper or lower bounds. Specializations of this collection include Integer, RationalNumber, and NegativeNumber. Note that RealNumber is also a specialization of ComplexNumber (q.v.), and any instance of the former constitutes a degenerate case of the latter, in that the value along the real's \"imaginary axis\" is zero (cf. ImaginaryNumber)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vQuotientFn,"An instance of both BinaryFunction and EvaluatableFunction. When applied to an instance DIVIDEND of ScalarInterval and an instance DIVISOR of ScalarInterval, QuotientFn returns an instance of ScalarInterval that is the result of dividing DIVIDEND by DIVISOR. For example, (QuotientFn 24 6) is 4, (QuotientFn (Meter 3) (SecondsDuration 2)) is (MetersPerSecond 1.5) (i.e., 1.5 meters per second), and (QuotientFn (SecondsDuration 2) (Meter 3)) is ((PerFn SecondsDuration Meter) 0.6666666666666666) (i.e., 0.6666666666666666 seconds per meter). Note that (QuotientFn DIVIDEND 0) is undefined for any instance DIVIDEND of ScalarInterval."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtQuintaryPredicate,"A specialization of Predicate and QuintaryRelation. QuintaryPredicate is the collection of all predicates whose arity (see arity) is 5."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtQuintaryFunction,"A specialization of both QuintaryRelation and Function-Denotational. An instance of Function-Denotational FUNC is an instance of QuintaryFunction if and only if FUNC has an arity of 5."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtQuaternaryPredicate,"A specialization of both QuaternaryRelation and Predicate. QuaternaryPredicate is the collection of all predicates whose arity (see arity) is 4."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vQuantityConversionFn,"(QuantityConversionFn UNIT QUANTITY) converts QUANTITY into an equivalent quantity expressed using UNIT as the unit of measure. For example, (QuantityConversionFn Inch (Foot-UnitOfMeasure 2)) denotes (Inch 24)."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(rtQuantifier,"A specialization of SententialRelation and ScopingRelation (qq.v.). Each instance of Quantifier takes as its arguments (at least) a variable (see CycLVariable) and a sentence (see CycLSentence-Assertible), and is used to make a certain kind of generic quantitative statement regarding the things that satisfy the sentence. Typically, the variable VAR will occur free in the sentence SENT, and in the quantified sentence (QUANT VAR SENT ...) these occurrences of VAR are bound by that occurrence of QUANT. (If VAR does not occur free in SENT, then the quantified sentence is a \"vacuous quantification\" that is equivalent to SENT by itself. For the definitions of 'free' and 'bound' occurrences of variables, see ScopingRelation.) For example, '(thereExists ?X (isa ?X Dog))' means that there exists at least one dog. Other instances of Quantifier are forAll, thereExistExactly, thereExistAtLeast, and thereExistAtMost."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(prettyStringCanonical,"(prettyString TERM STRING) means that STRING is the English word or expression (sequence of words) commonly used to refer to TERM. The predicate prettyString is used by the code which generates CycL to English paraphrases, but its applicability is not restricted to this use."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ttPredicateTypeByArity,"A collection of collections. Each instance of PredicateTypeByArity is a collection of Predicates having the same arity. Instances include UnaryPredicate, BinaryPredicate, and TernaryPredicate."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(tPred,"A specialization of TruthFunction (q.v.). Each instance of Predicate is either a property of things (see UnaryPredicate) or a relationship holding between two or more things. Like other truth-functions, predicates, or rather the expressions that represent or denote them, are used to form sentences. More precisely, any CycL expression that denotes an instance of Predicate (and only such an expression) can appear in the \"0th\" (or \"arg0\") position (i.e. as the term following the opening parenthesis) of a CycLAtomicSentence (q.v.). Important specializations of Predicate include UnaryPredicate, BinaryPredicate, TernaryPredicate, QuaternaryPredicate, and QuintaryPredicate. Note that, despite its name, Predicate is a collection of relations, and not a collection of expressions that represent or denote such relations."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(ftPositiveInteger,"A specialization of Integer. An instance INT of Integer is an instance of PositiveInteger just in case INT is an integer greater than 0."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vPlusFn,"A variable-arity MathematicalFunctionOnScalars that is an extension of the arithmetical operation of addition to measurable ScalarIntervals (q.v.) generally. Where ADDEND1, ..., and ADDENDn are pairwise numericallyComparable (q.v.), (PlusFn ADDEND1 ... ADDENDn) is the arithmetic sum of ADDEND1, ..., and ADDENDn. For example, (PlusFn 2 3 4) is 9, and (PlusFn (Meter 1.5) (Meter 0.7)) is (Meter 2.2).\n

\nNote that the term (PlusFn ADDEND1 ... ADDENDn) is undefined if there are ADDENDi and ADDENDj (1 <= i,j <= n) that are not comparable. For example, (PlusFn (MinutesDuration 1) (Meter 3)) is undefined, since (MinutesDuration 1) is a Time-Quantity and (Meter 3) is a Distance, and time-quantities are not comparable with distances.\n

\nFor subtraction, see DifferenceFn."),iUniversalVocabularyMt,vStrDef). tiny_kb(comment(vPlusAllFn,"A NumericQuantifier function that takes a SetOrCollection and a UnaryFunction as its arguments. (PlusAll SETORCOL FUNC) is the result of adding up the results of successively applying FUNC to each element of SETORCOL. For example:\n

\n    (PlusAll (TheSet 4 9) SquareRootFn)\n  = (PlusFn (SquareRootFn 4) (SquareRootFn 9))\n  = (PlusFn 2 3)\n  = 5."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(cycPerFn,"A binary UnitOfMeasureDenotingFunction (q.v.) that takes two UnitOfMeasure (q.v.) functions and returns a UnitOfRatio (q.v.) composed of them.  (PerFn UNIT1 UNIT2) is a unit RATIO-FN for measuring the ratio of UNIT1 units to UNIT2 units.   That is, for any number or other NumericInterval NUM, (RATIO-FN NUM) = (QuotientFn (UNIT1 NUM) (UNIT2 1)).\n
\nFor example, (PerFn Meter SecondsDuration) is a UnitOfSpeed function that measures meters-per-second.  When applied to (e.g.) the integer 20, this unit-of-speed returns the particular Speed equal to\n
\n  (QuotientFn (Meter 20) (SecondsDuration 1))\n
\nor 20 meters-per-second.\n
\nNote that UNIT1 and UNIT2 must not be interconvertibleUnits (q.v.), or (PerFn UNIT1 UNIT2) is undefined.  Otherwise, UNIT1 and UNIT2 would effectively \"cancel each other out\", and the value returned by PerFn for those arguments would not be a UnitOfRatio.\n
\nSee also UnitProductFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vPercentFn,"A variable-arity MathematicalFunctionOnScalars (q.v.).  When applied to a number or other NumericInterval (pair of numeric-intervals), Percent returns the instance of IntervalOnNumberLine that is its argument (the interval between its two arguments) divided by 100.  For example (Percent 110) is 1.1, and (Percent 10 20) is (Unity 0.1 0.2): the interval between 0.1 and 0.2 inclusive."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtPartiallyCommutativeRelation,"An instance of RelationTypeByLogicalFeature (q.v.) and a specialization of AtLeastPartiallyCommutativeRelation.  Each instance  of PartiallyCommutativeRelation PARTCOMRELN is a predicate or function that is commutative in some, but not all, of its argument-places (see  commutativeInArgs).  More precisely, suppose for example that PARTCOMRELN is a predicate (function) that is commutative only in its odd-numbered  argument-places, and that PARTCOMRELN holds among (has the value VAL for) a given sequence of arguments SEQ.  It follows that PARTCOMRELN also holds among (has the same value VAL for) any other sequence SEQ-PRIME obtainable from SEQ by permuting some or all of the odd-numbered members of SEQ while keeping all of its even-numbered members fixed.\n
\nNote that PARTCOMRELN must  have an arity (see arity) of at least three and cannot be an instance of CommutativeRelation (as any instance of the latter is commutative in all of its argument-places).\n
\nInstances of PartiallyCommutativeRelation include pathsJoinAt, formsBorderBetween, and BlockOfStreetBetweenFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vOctober,"A specialization of CalendarMonth.  Each instance of October is the tenth month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vNovember,"A specialization of CalendarMonth. Each instance of November is the eleventh month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonNegativeScalarInterval,"A specialization of ScalarInterval.  An instance INTERVAL of ScalarInterval is also an instance of NonNegativeScalarInterval just in case INTERVAL is a non-negative number or quantity.  Instances of NonNegativeScalarInterval include all instances of NonNegativeNumber (q.v.), as well as non-negative quantities such as (Meter 212), (Kilogram 5), and (SecondsDuration 0)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonNegativeInteger,"NonNegativeInteger is the sub-collection of Integer that excludes the negative integers.  Each instance of NonNegativeInteger is a whole number greater than or equal to zero -- for example, 0, 1, 2, 3, ...."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tMultigraph,"An instance of PathSystemType-Structural and a subcollection of PathSystem.  Each instance of Multigraph is an instance of PathSystem in which the only points are nodes in the system and all paths are made of links (i.e., no intermediate points along links). Sometime such a system is called a graph or multi-graph in graph theory.  A Multigraph consists of nodes interconnected by links, with loops on single nodes allowed, and with multiple links between the same two nodes also allowed.  (For a graph with no parallel links and no loops, see SimpleGraph-GraphTheoretic."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vtMonthOfYearType,"A collection of Collections.\nInstances of MonthOfYearType are the canonical subcollections of CalendarMonth.  There are twelve of these in the JulianCalendar; for example, September is the collection of all Septembers."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMinRangeFn,"An instance of both VariableArityRelation and EvaluatableFunction.  When applied to instances QUANTITY1, ..., QUANTITYN  of ScalarInterval, MinRangeFn yields an instance of ScalarInterval that is the largest interval subsumed by each of QUANTITY1 through QUANTITYN.  \n
\nFor example, (MinRangeFn  (Meter 1 3) (Meter 2 4)) is (Meter 2 3). \n
\nNote that if one of the instances QUANTITY1, ..., QUANTITYN fails to intersect with at least one of the other instances, then the result of applying MinRangeFn to QUANTITY1, ..., QUANTITYN is undefined (for example, both (MinRangeFn (Meter 1 1.5) (Meter 2 4) (Meter 0 5)) and (MinRangeFn (SecondsDuration 3 5) (Meter 1 4)) are undefined).  See also MaxRangeFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMinimumFn,"Computes the minimum of a unary function's values over all elements in a given set or collection.  That is, (Minimum SETORCOL FUNC) denotes the value of FUNC for the element ELEM of SETORCOL taken as argument (if any) such that (FUNC ELEM) is less than or equal to (FUNC OTHER) for any element OTHER of SETORCOL other than ELEM.  Note that (Minimum SETORCOL IdentityFn) denotes the minimum element of SETORCOL itself."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtMicrotheoryDesignatingRelation,"The collection of Relations which specify that a ELSentence-Assertible is to be interpreted in a given Microtheory.  It will be canonicalized and checked for well-formedness with respect to that microtheory. Each microtheory-designating relation has an argument which denotes a microtheory, and another argument which denotes a ELSentence-Assertible.  It may have other arguments as well. Use microtheoryDesignationArgnum and sentenceDesignationArgnum to specify these argument positions for each microtheory-designating relation."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tMicrotheory,"A specialization of AspatialInformationStore and AbstractIndividual (qq.v.).  Each instance of Microtheory is an atemporal, aspatial, informational thing that represents a context in Cyc.  Each microtheory (or 'mt') serves to group a set of assertions together that share some common assumptions; the assertions in an mt constitute the content of that mt.  Note that each assertion in the Cyc knowledge base must be explicitly stated to be true in at least one microtheory.  Assertions stated to be true in one mt will also be true  (by inference) in more specialized mts that depend on the content of that mt.  For example, if something is true in the HumanSocialLifeMt (q.v.), then it should by default be true in the more specialized UnitedStatesSocialLifeMt (q.v.).  Specialized microtheories are related to the more general microtheories on which they depend by the predicate genlMt (q.v.).  Note that every query is made in some mt, and the answer one gets to a query depends on the mt in which it is asked, since the only assertions which can be used to answer a query in an mt are those  explicitly stated to be true in that mt, or in some more general mt.  See also the predicate ist, which is used to relate an assertion to the microtheories in which it is true."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(iMeaningInSystemFn,"A reifiable BinaryFunction that returns the meaningful entities indexed by a particular character string in a Cyc-external information source. More precisely, (MeaningInSystemFn INFOSOURCE STRING), applied to the CharacterString STRING and the IndexedInformationSource INFOSOURCE, returns whatever is indexed by STRING in that system.  For example, (MeaningInSystemFn WordNet-1997Version \"N03585958\") returns the WordNet `synset' (`synonym set') represented by (rampart|bulwark|wall), meaning \"an embankment built around a space for defensive purposes\".\n
\nSTRING can have any format chosen by the person who builds the representation of the external system.  In addition, STRING may contain arbitrary further characters or information, depending on how the external information is selected and processed.  This function makes it possible to relate a concept in an external system to an arbitrarily complicated expression composed of Cyc concepts.  If the external concept has a direct, exact mapping to a single Cyc constant, then use the predicate synonymousExternalConcept rather than this function.  If there is correspondence only to one Cyc constant, but it is only approximate, use overlappingExternalConcept."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMay,"A specialization of CalendarMonth. Each instance of May is the fifth month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMaxRangeFn,"(MaxRangeFn QUANTITY1 ... QUANTITYN) denotes a quantity which subsumes each of QUANTITY1 through QUANTITYN.  For example, (MaxRangeFn (Meter 1 3) (Meter 2 4)) denotes (Meter 1 4).  See also MinRangeFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMaximumFn,"A NumericQuantifier.  Used to denote the maximum quantity which results from applying the function specified in the second argument to all of the elements of the set expression which appears in the first argument.--Rode 3/15/98"),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vMarch,"A specialization of CalendarMonth. Each instance of March is the third month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtLogicalConnective,"A collection of mathematical objects, including the basic logical connectives.  Each instance of LogicalConnective is a Relation which takes one or more truth-valued expressions (sentences) as arguments and returns a truth-valued sentence.  The instances of LogicalConnective include and, or, not, and implies."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vLogFn,"A unary EvaluatableFunction that returns the natural logarithm of the number taken as its argument.  (LogFn NUM) is the exponent to which e is raised to get NUM (where e is E-LogarithmBase). Its inverse (cf. inverseQuantFunctions-Nonsymmetric) is ExpFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftList,"A specialization of Tuple.  Each instance of List is a  finite sequence of things with a first and last member-position, with each member-position other than the last having a successor member-position.   As with tuples generally, lists allow for repetition of their members, so that the same item can appear at multiple member-positions in the same list.  A list can be represented formally as a function from a finite index set of counting numbers, beginning with one, into the domain of all Things (but note that Lists are _not_ explicitly represented as functions in the Cyc ontology).  Unlike an instance of Series (q.v.), a list is purely abstract (i.e. both aspatial and atemporal), and the only implied relation between an item and its successor in a list is the successor relation of the list itself.  Technically, List is more specific than Tuple only in that the index set (see tupleIndexSet) for a given list must be the counting numbers in their usual order (or some initial segment thereof), whereas the index set for a tuple, generally speaking, might be any set whatsoever."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(iKappaFn,"A binary PredicateDenotingFunction and a ScopingRelation (qq.v.), Kappa is used to define a predicate on the basis of a sentence (see CycLSentence-Assertible) and a list of variables (see CycLVariableList) some or all of which typically occur free in the sentence.  The resulting predicate holds of just those sequences that would make the sentence true.\n
\nMore precisely, if VAR1,...,VARN include all of the CycLVariables that occur free in SENT, then the term\n
\n  (Kappa (VAR1 ... VARN) SENT)\n
\ndenotes the N-ary relation (i.e. the Predicate) that holds of any admitted sequence of arguments ARG1...ARGN if and only if SENT[ARGI/VARI] is true, where SENT[ARGI/VARI] is the result of simultaneously replacing each free occurrence of VARI in SENT with a CycL name of the corresponding ARGI (for 1 <= I <= N). \n
\n(With respect to the above, ARG1...ARGN is an admitted sequence of arguments to (Kappa (VAR1 ... VARN) SENT) just in case (i) each ARGI satisfies any argument-type constraints applicable to the position(s) occupied by VARI in SENT and (ii) if any two variables VARI and VARJ are the same then the corresponding sequence-members ARGI and ARGJ are identical.)\n
\nA few examples.  (Kappa (?X) (greaterThan ?X 1)) is a unary predicate that holds of all numbers greater than 1. (Kappa (?X ?Y) (greaterThan ?X 1)) is a binary predicate that holds of any ordered pair of argument values whose first member is a number greater than 1. (Kappa (?X) (greaterThan 2 1)) is a unary predicate that holds of any thing.  (Kappa (?X) (greaterThan 1 2)) is a unary predicate that holds of no thing.  (Kappa (?X ?X) (greaterThan ?X 1)) is a binary predicate that holds of any ordered pair of numbers whose first and second members are the same number K, where K is greater than 1.\n
\nMost of the above examples are uses of Kappa that have little utility.  The first example, however, is an example of a common and important use of Kappa, which is to reduce the arity of a predicate by fixing the value for one or more of its arguments. For example, (Kappa (?COUNTRY ?RATE) (exportRate ?COUNTRY Oil ?RATE)) defines a binary predicate that relates a country to its export rate of oil, whereas (Kappa (?COUNTRY) (exportRate ?COUNTRY Oil (MillionBarrelsPerDay 2))) defines a unary predicate that holds of any country that exports oil at the rate of two million barrels per day.\n
\nThe sentence that is an argument to Kappa may be arbitrarily complex.  For example, it may be an existentially quantified conjunction.  Thus,\n
\n   (Kappa (?PERSON ?NAME)\n    (thereExists ?FATHER\n      (and\n        (isa ?PERSON Person)\n        (father ?PERSON ?FATHER)\n        (lastName ?FATHER ?NAME))\n
\n
\nreturns a predicate that holds of any ordered pair , such that PERSON is a person whose father's last name is NAME.\n
\nSometimes it is useful to construct an expression of the form (Kappa LIST SENT) where some variables that occur free in SENT do not occur in LIST.  For example, (Kappa (?X) (greaterThan ?X ?Y)) might be used in a context where the ?Y appears within the scope of a quantifier that occurs outside of the Kappa expression.\n
\nKappa is a cousin of the function Lambda (q.v.), which is used to define a function on the basis of a list of variables and a non-logical term."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vJune,"A specialization of CalendarMonth.  Each instance of June is the sixth month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vJuly,"The collection of all Julys,\n the seventh month of the year in the GregorianCalendar."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vJanuary,"A specialization of CalendarMonth.  Each instance of January is the first month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtIrreflexiveBinaryPredicate,"The collection of BinaryPredicates that are irreflexive.  A binary predicate PRED is an instance of IrreflexiveBinaryPredicate only if, for every THING that satisfies the single-argument type-constraints (i.e. argIsa and argGenls; see admittedArgument) on both of PRED's argument-places, (not (PRED THING THING)) holds.\n
\nTo rule out \"vacuous\" cases, there is an additional necessary condition for irreflexivity:  the constraints on PRED's two argument-places must be co-satisfiable (see cosatisfiableInArgs).  Without this requirement, any binary predicate whose arguments were constrained in mutually-disjoint ways would trivially (and counterintuitively) count as irreflexive.  See NoteOnArgumentCosatisfiabilityRequirement\n
\nExamples of irreflexive binary predicates include spouse, causes-ThingProp, northOf, and temporallyDisjoint."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vIntervalMinFn,"(IntervalMinFn SCALAR) returns an interval of the same type as SCALAR whose minimum value is the minimum value of SCALAR and whose maximum value is PlusInfinity.  For example, (IntervalMinFn (Mile 3)) is the same as `the interval from three miles to an infinite number of miles', in other words, `at least three miles'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vIntervalMaxFn,"(IntervalMaxFn SCALAR) returns an interval of the same type as SCALAR whose maximum value is the maximum value of SCALAR and whose minimum value is minus infinity.  For example, (IntervalMaxFn (Mile 3)) is the same as `the interval from negative infinity miles to three miles'. [Technical Note: if that expression were to denote a strictly absolute, as opposed to a relative-or-absolute, distance, then it would mean `the interval from 0 miles to 3 miles'.]   (IntervalMaxFn (Unity 1)) is the same as `the interval from negative infinity to 1', in other words, `no greater than one'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtInterArgIsaPredicate,"The subcollection of both InterArgTypePredicate and ArgIsaPredicate (qq.v.) whose instances are used to put conditional isa based argument-type constraints on polyadic relations in regards to two of their argument-places.  Each instance of InterArgIsaPredicate specifies, with respect to a given Relation, that one of its arguments (the \"dependent\" one) must be an instance of (isa) a certain collection, contingent upon another of its argument's (the \"independent\" one's) being an instance of a certain (possibly different) collection.  An inter-argument-isa predicate PRED has argument-places for designating the relation and the two collections serving as argument-types; the (numerically-specified) identities of the relation's corresponding dependent and independent arguments is in most cases fixed (as in interArgIsa1-2), but is in some cases variable and specified via two additional argument-places of PRED's (as in interArgIsa).  In cases of the former sort, where the relation's argument-places are fixed, PRED is a TernaryPredicate that takes as it first argument (or \"arg1\") a relation, as its arg2 the type specified for the relation's independent argument, and as its arg3 the type specified (contingently) for the dependent argument."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(interArgGenl1_2,"(interArgGenl1-2 REL INDEPENDENT-COL DEPENDENT-COL) means that, when a spec of INDEPENDENT-COL appears as the first argument to REL, the second argument is constrained to be a spec of DEPENDENT-COL."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtInterArgFormatPredicate,"The subcollection of both InterArgConstraintPredicate and ArgFormatPredicate (qq.v.) whose instances are used to specify, for a given predicate PRED, a certain Format requirement on one of PRED's arguments (the \"dependent\" one), contingent upon one (usually, but not always, a different one) of PRED's arguments (the \"independent\" one) being an instance of (isa) a certain collection.  Currently, each instance of InterArgFormatPredicate is ternary, where its first argument (or \"arg1\") is the predicate PRED upon which the constraint is being placed, its arg2 the collection serving as the isa condition on PRED's independent argument, and its arg3 the Format that PRED's dependent argument is (conditionally) constrained to have.  The (numerically-specified) identities of the arguments of PRED's that are to serve as the independent and dependent arguments are fixed for each instance of \nInterArgFormatPredicate."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftInt,"A specialization of RationalNumber.  Each instance of Integer is a whole number with no fractional remainder.  An integer may be positive (e.g. 42), zero, or negative (e.g. -42).\n
\nNote that, in the KB browser, a fixed- or floating-point number representation such as `42.00' should not be assumed to refer to the integer 42. For it might only appear to correspond to that integer within the tolerance of its representation, and might in fact be an approximation to a non-integer number such as 42.0003.\n
\nAlso note that, unlike Integer, SubLInteger (q.v.) is a collection of integer-denoting expressions in the SubL programming language rather than a collection of integers themselves. Still, (genls SubLInteger Integer) holds, but only under a special interpretation of genls forced by the fact that SubLInteger is a quotedCollection (q.v).)"),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtInferenceRelatedBookkeepingPredicate,"A collection of predicates.  Each instance of InferenceRelatedBookkeepingPredicate is a predicate involved in assertions used by the Cyc application to direct inferencing.  Examples: defnIff, defnSufficient, termOfUnit, afterAdding."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tIndividual,"Individual is the collection of all individuals:  things that are not sets or collections.  Individuals might be concrete or abstract, and include (among other things) physical objects, events, numbers,  relations, and groups.  An instance of Individual might have parts or  structure (including discontinuous parts); but no individual has elements  or subsets (see elementOf and subsetOf). Thus, an individual that has parts (e.g. physicalParts or groupMembers) is not the same thing as either the set or the collection containing those same parts.  For example, your car is an individual, but the collection of all the parts of your car is not an individual but an instance of Collection.  This collection (unlike the car itself) is abstract: it doesn't have a location, mass, or a top speed; but it does have instances, subcollections, and supercollections.  In partial contrast, the Group (q.v.) of parts of your car (while also not the same thing as the car itself) is an individual that has location and mass.  Another example: A given company, the group consisting of all the company's employees, the collection of those employees, and the set of those employees are four distinct things, and only the first two are individuals."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(mtHypotheticalContext,"A MicrotheoryType.  Each instance of  HypotheticalContext consists of assertions that are posited strictly for the purpose of exploring their consequences, without alleging their actual truth.   A hypothetical context can be used to analyze hypothetical outcomes of actions or to examine the hypothetical consequences of assuming some theory to be true.  Also, various alternative choices might be asserted, each in its own hypothetical context, so their ramifications can be generated and compared."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tHumanCyclist,"A specialization of Cyclist and Person.  Each instance of  HumanCyclist is a person who is entitled to inspect and modify the Cyc knowledge base."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftHLPrototypicalTerm,"The collection of all CycLTerms that are the hlPrototypicalInstance of some collection.  All HLPrototypicalTerms are IndeterminateTerms."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(iFunctionToArgFn,"A binary FunctionDenotingFunction (q.v.) that takes as argument a FunctionalPredicate (and an integer indicating an argument-place in which that predicate is functional) and returns the corresponding function (whose value is always equal to the predicate's corresponding argument in the indicated place).\n
\nMore precisely: if PRED is an N-ary functional predicate that is functional in its Mth argument (see functionalInArgs), then (FunctionToArg M PRED) is the (N-1)-ary function FUNC-TO-ARGM such that (PRED ARG(1) ... ARG(N)) holds if and only if (FUNC-TO-ARGM ARG(1) ... ARG(M-1) ARG(M+1) ... ARG(N)) = ARG(M).  If PRED is not functional in its Mth argument, then (FunctionToArg PRED M) is undefined.\n
\nFor example, (FunctionToArg 2 age) is the function that returns the age of a given person.  Thus ((FunctionToArg 2 age) GeorgeWBush) = (YearsDuration 50) just in case (age GeorgeWBush (YearsDuration 50)) is true.\n
\nSee also Lambda and Kappa."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tFunction,"A specialization of Relation (q.v.) and the collection of all functions.  Each instance of Function-Denotational is a many-one relation that represents, with respect to any given context, a mapping from one set of things (the function's relationDomain) to another set of things (its relationRange).  As a many-one relation, a function maps each thing in its domain to exactly one thing in its range.  A function might be unary, binary, ternary, etc. (see arity; but cf. relationalArity), depending on whether the members of its domain are singletons, ordered pairs, ordered triples, etc.  In general, the domain of an N-ary function with respect to a given context is a set of ordered N-tuples (construed in CycL as Lists of length N).  The function is said to take the items from any of these N-tuples as its N arguments and to return a member of its range as its corresponding value (see valueOfFunctionForArgs).  There are also functions that are not of any particular fixed arity; see VariableArityFunction.\n
\nFor example, GovernmentFn is the unary function that takes each GeopoliticalEntity to its RegionalGovernment, and PlusFn is the variable-arity function that takes any sequence of two or more ScalarIntervals\n(q.v.) to their arithmetic sum.\n
\nNote that the domain and range (i.e. the extension) of a given function might vary from context to context.  For example, as the government of a country can change over time, GovernmentFn will in such cases map the same country to different governments with respect to different times.  Thus, an instance of Function-Denotational is closer to what is sometimes called a \"function-in-intension\" than to the purely set-theoretical notion of a \"function-in-extension\".\n
\nCycL terms that denote functions can be used to form non-atomic terms (or \"NATs\"; see CycLClosedNonAtomicTerm).  Specifically, when such a function-denoting expression is appropriately combined with other expressions (i.e. the former is in the 0th argument position and the latter are of the correct number and type) the resulting expression is a new CycL term (a NAT) that may then freely appear as a component in other CycL expressions.  The NAT will itself denote the value (if any) of the function denoted by the former expression for the sequence of arguments denoted, respectively, by the latter expressions.  For example, GovernmentFn is a unary function, and so the CycL constant 'GovernmentFn' requires one syntactic argument (such as the constant 'France') to form a NAT (in this case, the expression '(GovernmentFn France)').  This NAT, which denotes the government of France, can in turn serve as a syntactic argument in any CycL expression in which a term for an instance of RegionalGovernment can legally occur.\n
\nImportant subcollections of Function-Denotational include IndividualDenotingFunction (whose instances always return instances of Individual), CollectionDenotingFunction, SetDenotingFunction, and FunctionDenotingFunction (which is itself a subcollection of the first).  NATs formed using terms that denote instances of FunctionDenotingFunction denote instances of Function-Denotational themselves.  Thus, like most other things, functions can be denoted in CycL either by constants  (e.g. 'GovernmentFn') or -- although this is less common -- by NATs (e.g.  '(FunctionToArg 2 biologicalMother)').\n
\nAn important partition of Function-Denotational is into TotalFunction and PartialFunction (qq.v.).\n
\nNote that Function-Denotational does not include any of the so-called TruthFunctions (q.v.): Predicates, Quantifiers, or LogicalConnectives. For these relations (as construed in CycL) are not really functions at all, even though it can be heuristically useful to think of them as if they were functions from sequences of arguments to truth values."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vFormulaArityFn,"An instance of EvaluatableFunction.  When applied to a CycLFormula FORM, FormulaArityFn returns the number of arguments given to the relation (an instance of Relation (q.v.)) appearing in the initial (\"arg0\") argument place of FORM."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(uFormulaArgFn,"A binary function that returns an instance of CycLTerm when given an instance of NonNegativeInteger and an instance of CycLFormula as arguments.  (FormulaArgFn N RELATION-EXPRESSION) denotes the term appearing as the Nth argument within RELATION-EXPRESSION. (Note that RELATION-EXPRESSION may be a sentence or a NAT). For example:\n
\n(FormulaArgFn 2 (loves Gilbert Muffet)) and\n(FormulaArgFn 1 (BirthFn Muffet))\n
\nboth denote Muffet. Cf. ArgPositionFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vtFormat,"A collection of argument entry-formats that can be  specified for Predicates with respect to particular argument-places (see argFormat).  An argument entry-format is a kind of restriction on  a predicate regarding how many things, or the range of things, that the  predicate holds of with respect to a given one of its argument-places.  More  precisely: given any particular way of fixing the arguments in the rest of  the predicate's argument-places, the entry-format tells us something about  the number of different things, or the range of things, that can occupy the  given argument-place such that the relation holds of those arguments.  That is, supposing the given argument-place is the Nth, the entry-format tells us  something about the number or range of different sequences of arguments  of which the predicate holds and that differ from each other only in their Nth items.  For example, the format SingleEntry (q.v.) is used to state  that in every case there is at most only one such sequence, the format  SetTheFormat (q.v.) to state that there is no particular (upper or lower)  limit to the number of such sequences that applies to every case, and the  format IntervalEntry (q.v.) to state that the Nth items of any two such  sequences must be ScalarIntervals that \"intersect\" (see quantityIntersects). Thus, the first argument-place of biologicalMother has the format (see  arg1Format) SetTheFormat, since a given female animal might have any  number (including zero) of offspring; but the second argument-place of  this predicate has (see arg2Format) SingleEntry format, since any  given animal has at most (in fact, exactly) one biological mother.  And  the format of the second argument-place of bodyTemperature is IntervalEntry because, while a given creature (at a given moment in time) has a single  exact (see ScalarPointValue) body temperature, we want the predicate bodyTemperature to be flexible enough to allow us to specify this  temperature with varying degrees of precision (e.g. as \"98.6 degrees Fahrenheit\" or as \"between 98 and 99 degrees\" or as \"less than 100 degrees\").  See the various instances of Format for further details.  See also ArgFormatPredicate.  Note that, in contrast with what ArgTypePredicates  are used for, specifying an argument entry-format for a predicate does  _not_ impose any sort of necessary condition for semantic well-formedness.   A violation of a legitimate entry-format constraint necessarily involves  two or more statements, and at least one them must be _untrue_;  but there is no implication that any of them is malformed."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtFixedAritySkolemFunction,"The subcollection of SkolemFunctions whose arity is fixed. This is the most common type of skolem function, since variable- arity skolem functions are only created when a sequence variable is in the scope of the skolem."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(cycFixedAritySkolemFuncN,"The collection of SkolemFuncNs (q.v.) whose arity is fixed."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtFixedArityRelation,"A specialization of Relation.  A Relation is an instance  of FixedArityRelation just in case it takes a fixed number  of arguments.  Most relations reified in the Cyc ontology are  of fixed arity.  For example, likesAsFriend always takes two  arguments and pointOfContact three.  This collection is  disjoint with VariableArityRelation."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vFebruary,"The collection of all Februaries,  the second month of the year in the GregorianCalendar."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vExistentialQuantifierBounded,"A specialization of ExistentialQuantifier (q.v.).  Each instance of ExistentialQuantifier-Bounded is a ternary relation that can be used to make a certain kind of statement about the existence of a given bounded quantity of things meeting a given criterion.  For example, '(thereExistAtLeast 9 ?X (isa ?X Cat))' means that there exist at least nine cats.  What distinguishes _bounded_ existential quantifiers from existential quantifiers generally is that the former require one to specify explicitly (at least a boundary for) how many things exist that meet the specified criterion."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtExistentialQuantifier,"A specialization of Quantifier (q.v.).  Each instance of ExistentialQuantifier can be used to make a certain kind of assertion regarding the existence of some thing(s) meeting a specified criterion.  For example, `(thereExistAtLeast 9 ?X (isa ?X Cat))' means that there exist at least nine cats.  Other instances of this collection are thereExists and thereExistExactly.  Cf. forAll."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtEvaluatableRelation,"A specialization of Relation.  Each instance of EvaluatableRelation is\na function or predicate for which there is some piece of system code that \ncan be invoked to evaluate (i.e. to determine the denotation or truth-value\nof) a closed expression built from that function or predicate (i.e. a closed \nexpression that has the constant that denotes that function or predicate in \nits initial or \"0th\" argument-place).  An evaluation of this sort is carried \nout, for example, when the system is queried using an evaluate (q.v.) \nsentence.  As one might expect, most evaluatable relations are mathematical \nor syntactic in nature; for numbers, sets, lists, and strings are the sorts \nof things that are related in various ways that can be calculated \nalgorithmically.  Examples include PlusFn, greaterThan, JoinListsFn, \nand substring.  In the case of a function that is evaluatable (see \nEvaluatableFunction), the practical result of evaluating the relevant \nexpression is another _term_ -- one that has the same denotatum as the \noriginal expression, but that is syntactically simpler and constitutes a \nmore straightforward way of referring to that denotatum.  For example, \nthe term `(PlusFn (Inch 3) (Inch 1))', when evaluated, results in \nthe term `(Inch 4)'.  So if a query using the open sentence\n`(evaluate ?X (PlusFn (Inch 3) (Inch 1)))' is asked, the answer \n(or \"binding\" for the variable `?X') returned will be the term `(Inch 4)'.  \nEvaluating a sentence built from (a constant that denotes) an \nEvaluatablePredicate, on the other hand, yields a _truth-value_.  For \nexample, the sentence `(greaterThan (Inch 3) (Inch 1))' evaluates \nto (and so if used to ask a query will return the answer) `True'.  The \npredicate evaluationDefn (q.v.) is used to specify the name of the piece \nof system code used to evaluate expressions formed with a given \nevaluatable relation."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtEvaluatableFunction,"A specialization of both EvaluatableRelation and Function-Denotational (qq.v.).  Each instance of EvaluatableFunction is a function that is associated (via evaluationDefn) with a piece of HL (\"heuristic level\") code that computes the result of applying the function to arguments for which that function is defined.  An evaluation of this sort is carried out, for example, when the system is queried using an evaluate (q.v.) sentence.  As one might expect, most evaluatable functions are mathematical or syntactic in nature; for, unlike with functions generally, operations on numbers, sets, lists, and strings can in many cases be calculated algorithmically.  Examples include PlusFn and JoinListsFn.  The practical result of evaluating a term built from (a constant that denotes) an evaluatable function is another _term_ -- one that has the same denotatum as the former term, but that is syntactically simpler and constitutes a more straightforward way of referring to that denotatum.  For example, the term '(PlusFn 2 3 4)', when evaluated, results in the term '9'.  So if a query using the open sentence '(evaluate ?X (PlusFn 2 3 4))' is asked, the answer (or \"binding\" for the free variable '?X') returned will be the term `9'.  By way of contrast, consider the non-evaluatable function BorderBetweenFn and the following arbitrarily-chosen non-atomic term built with its CycL name: '(BorderBetweenFn France Germany)'.  As there is no general algorithm for finding simpler or \"standard\" terms for given geographical borders, it is not possible for the Cyc system to \"evaluate\" non-atomic terms like this one."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(xEscapeQuoteFn,"A quotation-related device for making general statements about CycL expressions.  EscapeQuote is used to allow certain free variables occurring inside an expression that is quoted to \"escape\" (i.e. remain free with respect to) the quotation.  It is thus similar in function to, though more flexible than, QuasiQuote (q.v.).\n
\nTo be more precise: the syncategorematic symbol EscapeQuote is used in conjunction with the special quotation symbol Quote (q.v.) as a device for allowing genuinely free variables to occur inside quoted expressions, in order that one may meaningfully \"quantify into\" such expressions and thereby generalize over them.  Thus, EscapeQuote is used to indicate that the free variables occurring within its scope (which is itself inside the wider scope of an occurrence of Quote) are not themselves to be interpreted as being quoted.\n
\nThe syntax of EscapeQuote is such that it can only be used in conjunction with Quote.  For any CycL expression EXPR, (EscapeQuote EXPR) is not by itself a syntactically well-formed CycL expression; but the latter can appear as part of a well-formed expression, subject to the following restrictions.  (i) Any occurrence of EscapeQuote in a CycL expression must itself be inside the scope of an occurrence of Quote.  (ii) One occurrence of EscapeQuote can be inside the scope of another only if there is an intermediate occurrence of Quote (i.e. one whose scope subsumes that of the former and is subsumed by that of the latter).\n
\nThe semantics of EscapeQuote is such that a formula (Quote ... (EscapeQuote EXPR) ...) that contains only one occurrence of EscapeQuote means just what the corresponding formula (Quote ... EXPR ...) means, except that any free occurrence of a variable in EXPR is to be interpreted as still being genuinely free with respect to (Quote ... (EscapeQuote EXPR) ...).  In (Quote ... EXPR ...), by contrast, any such variables are taken to be regular quoted constituents of a quoted compound expression; thus they do not function there as variables, but as quoted-names of variables -- i.e. as terms that denote variables.  \n
\nFor example, while the term (Quote (isa ?X Cat)) simply denotes the open sentence (isa ?X Cat), the expression\n
\n  (Quote (EscapeQuote (isa ?X Cat)))\n
\nis itself an open term in which ?X occurs free; it thus does not denote in its own right, though many instantiations of it do denote.  E.g. the instantiation (Quote (EscapeQuote (isa Patches-Cat Cat))) denotes the sentence (isa Patches-Cat Cat)).\n
\nThe foregoing explanation generalizes to cases where multiple occurrences of EscapeQuote are within the scope of the same Quote.  For example, in the expression\n
\n  (Quote (loves (EscapeQuote ?X) (EscapeQuote ?Y)))\n
\n-- which is equivalent to (Quote (EscapeQuote (loves ?X ?Y))) -- both ?X and ?Y occur free.\n
\nAs mentioned above, the purpose of the EscapeQuote device is to enable \"quantifying into\" quoted contexts: to provide a coherent interpretation of formulas in which an occurrence of a Quantifier (or other ScopingRelation) that is outside the scope of a given occurrence of Quote can be viewed as binding occurrences of variables that are inside the scope of that Quote.  For example, the sentence\n
\n  (thereExists ?X\n    (and\n      (isa ?X Cat)\n      (isa (Quote (EscapeQuote ?X)) CycLAtomicTerm)))\n
\nsays that there is at least one cat that is denoted by a CycL atomic term.  Without the EscapeQuote wrapper, the second conjunct of the above would be a closed sentence, and the entire quantified sentence would express the far less interesting claim that there exists at least one cat and the expression ?X is an atomic term of CycL.\n
\nNote that the above (interesting) existential claim could be expressed more tersely using QuasiQuote.  EscapeQuote is indispensible only in cases where one wants to allow some but not all of the free variables in a given expression to escape quotation.  For example, in the (implicitly quantified) rule\n
\n  (isa\n    (Quote (loves ?X (EscapeQuote ?Y))) \n    CycLOpenSentence)\n
\nonly the variable ?Y occurs free; the ?X is part of what gets quoted (and thus functions like a closed term that denotes the CycL variable ?X).  What the rule says, in effect, is that any well-formed expression built with the predicate-expression loves followed by the variable ?X followed by a CycL term is an open sentence of CycL.\n
\nFor more on the use of EscapeQuote and Quote for quantifying into quoted contexts, see the shared NoteAboutQuotingInCycL. See also denotes, quotedIsa, quotedArgument, and NoteAboutSyncategorematicSymbols."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(equalStringsCaseinsensitive,"(equalStrings-CaseInsensitive STRING1 STRING2) means that the CharacterStrings STRING1 and STRING2 contain the same characters in the same order, although some of the characters in STRING1 may differ in case from some of the characters in STRING2.  For example, (equalStrings-CaseInsensitive \"Foo\" \"fOo\") holds."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(iELRelationReversible,"A specialization of ELRelation (q.v.) instances of which appear only at the \"epistemological level\" (or EL) of the Cyc system, but whose original forms, or logically equivalent variants thereof, are retrievable via the CycUncanonicalizer.  Each instance of ELRelation-Reversible is associated, via the expansion (q.v.) or expansionDefn relation, to a sentence template to which the former is essentially equivalent and for which the former serves as a convenient alternative.  Furthermore, each instance of ELRelation-Reversible is also associated with a piece of code which can perform the inverse transformation.  Since each instance of ELRelation-Reversible requires special code support, this is a notAssertibleCollection.  More precisely:  A GAF (see CycLClosedAtomicSentence) whose main functor (or \"0th argument\") is a term that denotes a reversible EL relation can occur only at the EL, and not at the underlying HL (\"heuristic level\") of the system.  Thus, although one can use an EL-relation-based GAF to make an assertion to the system, the GAF that actually gets stored as an assertion in the Cyc Knowledge Base is a different (though logically equivalent) one that is related to the first via the expansion or expansionDefn assertion on the EL relation.  Upon assertion, the first GAF is transformed into the second GAF by the CycCanonicalizer.  Upon presentation to the user, the second GAF is transformed back into the first GAF, or a GAF which is logically equivalent, by the CycUncanonicalizer.  For example, willAlwaysBe is a reversible EL relation whose expansionDefn and associated piece of uncanonicalization code perform the following transformation:\n
\n(ist (MtSpace (MtTimeDimFn TIME) OTHER-DIMS) (willAlwaysBe P)\n<==>\n(ist (MtSpace (MtTimeDimFn (IntervalStartedByFn TIME)) OTHER-DIMS) P)\n
\nSo if one makes an assertion into an MT with time index T using the sentence `(willAlwaysBe P)', the assertion that actually shows up in the KB is `P' in an MT with time index (IntervalStartedByFn T)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(iELRelationOneWay,"A specialization of ELRelation (q.v.) instances of which appear only when input at the \"epistemological level\" (or EL) of the Cyc system, and whose original EL form is thereafter irretrievable.  Each instance of ELRelation-OneWay is associated, via the expansion or expansionDefn relation, to a sentence template to which the former is essentially equivalent and for which the former serves as a convenient alternative.  More precisely: A GAF (see CycLClosedAtomicSentence) whose main  functor (or \"0th argument\") is a term that denotes a one-way EL relation can  occur only at the EL, and not at the underlying HL (\"heuristic level\") of the system.  Thus, although one can use a one-way-EL-relation-based GAF to make an assertion to the system, the GAF that actually gets stored as an assertion in the Cyc Knowledge Base is a different (though logically  equivalent) one that is related to the first via the expansion assertion  on the EL relation.  Upon assertion, the first GAF is \"transformed into\" the second GAF by the CycCanonicalizer.  For example, lessThan is a one-way EL relation whose expansion correlate is the template (greaterThan :ARG2 :ARG1).  So if one makes an assertion using the sentence `(lessThan 1 2)', the assertion that actually shows up in the KB is `(greaterThan 2 1)'.  Note that terms for one-way EL relations _do_ appear in stored assertions in which  they occur in argument places other than the 0th; e.g. the sentence `(isa lessThan OrderingPredicate)' is in the KB.  One-way EL relations afford cyclists the convenience of having alternative forms of expression, while their expansions serve to minimize redundancy in the types of GAFs that the system has to store and reason with."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtELRelation,"A specialization of MacroRelation (q.v.) instances of which appear only at the \"epistemological level\" (or EL) of the Cyc system.  Each instance of ELRelation is associated, via the expansion or expansionDefn relation, to a sentence template to which the former is essentially equivalent and for which the former serves as a convenient alternative.  Some assertions using instances of ELRelation are irretrievable after being input to the Cyc System (ELRelation-OneWay), and others' EL forms are reconstructed dynamically by the system (ELRelation-Reversible)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtDocumentationPredicate,"A PredicateType whose instances are Predicates specifically designed for in-KB documentation purposes, such as  facilitating Cyclists in their understanding of the Cyc system, tracking knowledge representation work being done in the Cyc Knowledge Base, or noting cleanup work to be done.  \n
\nNote that documentation predicates are usually not involved in inference.  They may be excluded from knowledge bases in which available memory is a premium without affecting the performance of applications. DocumentationPredicate is used in code to determine which documentation to show to the user when they request to see documentation for a first-order reified term (or \"FORT\")."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftDocumentationConstant,"A collection of CycL constants whose purpose is to facilitate users in their understanding of the system, tracking knowledge representation work being done, noting cleanup work to be done, etc. Documentation constants are usually not involved in inference.  Instances may be excluded from versions of the knowledge base in which available memory is a premium without affecting the performance of applications."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtDistributingMetaKnowledgePredicate,"A subcollection of MetaKnowledgePredicate (q.v.).  Each instance of DistributingMetaKnowledgePredicate is a meta-knowledge predicate that can be used to make meta-assertions (i.e it can take a CycLAssertion as an argument) and is such that, when applied to an EL-level assertion that polycanonicalizes (i.e. gets transformed by the Cyc canonicalizer into multiple HL-level assertions), it is automatically \"distributed\" over each of the multiple assertions resulting from the polycanonicalization.\n
\nLet METAPRED be an instance of DistributingMetaKnowledgePredicate. Suppose that one asserts (METAPRED ASSERTION FOO) and that ASSERTION polycanonicalizes into ASSERTION1 and ASSERTION2.  Then (METAPRED ASSERTION1 FOO) and (METAPRED ASSERTION2 FOO) will both be asserted to the Knowledge Base automatically.\n
\nFor example, if I assert this at the EL-level:\n
\n  (comment\n    (and (isa Muffet Dog) (likesAsFriend Muffet Patches-Cat))\n    \"Muffet digs Patches.\"),\n
\n
\nboth of these will automatically be asserted a the HL-level:\n
\n\t(comment (isa Muffet Dog) \"Muffet digs Patches.\")\n
\n\t(comment (likesAsFriend Muffet Patches-Cat) \"Muffet digs Patches.\") .\n
\nSee also the shared note MetaAssertionsForPolycanonicalizingAssertions."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ttDisjointCollectionType,"A collection of collections of collections and a specialization of SiblingDisjointCollectionType (q.v.).  A disjoint collection type is such that its instances are collections that are all disjoint from one another.  That is, each instance DISCOLTYPE of DisjointCollectionType is a collection whose instances are mutually disjoint collections: no two instances of DISCOLTYPE have any instances in common.  Instances of DisjointCollectionType include BiologicalSpecies and SportsTeamTypeBySport."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tDirectedMultigraph,"A specialization of both DirectedPathSystem and Multigraph.  Each instance of DirectedMultigraph is a multigraph in which every link has one direction.  Note that there can be loops and multiple links between a pair of nodes in a given instance of DirectedMultigraph."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vDifferenceFn,"A binary MathematicalFunctionOnScalars and an extension of the arithmetic subtraction operation to ScalarIntervals (q.v.) generally.  When applied to two arithmetically-comparable scalars, MINUEND and SUBTRAHEND, DifferenceFn yields the scalar that is the result of subtracting SUBTRAHEND from MINUEND.  For example, (DifferenceFn 88 11) is 77 and (DifferenceFn (Kilogram 4.2) (Kilogram 3)) is (Kilogram 1.2).\n
\nNote that when MINUEND and SUBTRAHEND are not arithmetically-comparable, (DifferenceFn MINUEND SUBTRAHEND) is undefined.  For example, (DifferenceFn (MinutesDuration 1) (Meter 3)) is undefined, since (MinutesDuration 1) is a Time-Quantity and (Meter 3) is a Distance, and time-quantities are not comparable with distances.\n
\nFor addition, see PlusFn."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtDefaultMonotonicPredicate,"A collection of predicates.  Each instance of DefaultMonotonicPredicate is a predicate whose use as the predicate of a locally asserted ground formula causes that formula to be entered, by default, as :MONOTONIC.  Examples: isa, genls, disjointWith, equals, arity, arg1Isa."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vDecember,"A specialization of CalendarMonth.  Each instance of December is the twelth and final month of a particular year in the GregorianCalendar (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vtDayOfWeekType,"A collection of collections and a specialization of WeeklyTemporalObjectType.\nEach instance of DayOfWeekType is a collection of CalendarDays, all of\nwhose instances correspond to the same particular \"day of the week\" in \nthe respective weeks in which they occur.  For example, Monday -- the \ncollection of all mondays -- is an instance of DayOfWeekType."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftVar,"The collection of all variables in the CycL language.\nA CycLVariable is a character string consisting of a question mark '?' (as its initial character) followed by one or more characters, where each of these latter characters is either an (upper- or lower-case) Roman letter, an Arabic numeral (i.e. '0' through '9'), a hyphen ('-'), an underscore ('_'), or another question mark.  (The letters occurring in a CycL variable used in an actual assertion will typically be all uppercase; but this convention is not enforced in any formal way.)  Examples: '?WHAT', '?OBJ-TYPE', and '?var0'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftExpression,"The collection of all syntactically well-formed   expressions in the CycL language that can be used as terms, i.e. that can be combined with other expressions to form non-atomic terms or formulas.  Since the grammar of the CycL language allows any CycL expression to be used as a term, CycLTerm and CycLExpression are coextensional collections."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentenceAssertible,"An instance of CycLExpressionType and a specialization of CycLExpression-Assertible and CycLSentence-Askable.  This is the collection of all CycL sentences that could be asserted to the Cyc Knowledge Base.  More precisely, each instance of CycLSentence-Assertible is a CycL sentence that is both syntactically and semantically well-formed.  By definition, any CycL sentence is syntactically well-formed.  To be semantically well-formed, a CycL sentence must be constructible via the syntax of CycL without violating any applicable arity or argument-type constraints (see arity and ArgTypePredicate).  A CycL sentence must be semantically well-formed in order to be interpretable as having a \"semantic value\", which for sentences means having a truth value.  Note that being \"assertible\" in the present sense does not require a sentences's actually being asserted in the KB."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentenceAskable,"The collection of CycLSentences that are askable as queries to the Cyc system.  More precisely, each  instance of CycLSentence-Askable is a CycL sentence that is  constructible via the syntax of CycL without violating any applicable  arity constraints (see arity).  Note that askable CycL sentences do  not necessarily obey other semantic constraints beyond arity, such as  argument-type constraints (see ArgTypePredicate); thus they are  not always semantically well-formed in the fullest sense (cf.  CycLSentence-Assertible).  The idea behind this criterion of  \"askability\" is that such a sentence, even if it isn't true or false (which it can't be unless it also obeys all argument-type  constraints), at least \"makes enough sense\" to be asked as a query  to the Cyc system."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentence,"The collection of syntactically well-formed sentences of the CycL language.  Each instance of CycLSentence consists of a CycL expression denoting an instance of TruthFunction (e.g. an instance of Predicate or SententialRelation) followed by one or more CycL terms (see CycLTerm), with the entire sequence enclosed in parentheses.  \n
\nFor example, (isa Collection Thing) and (genls ?FOO SpatialThing) are both CycL sentences.  Note that CycLSentences need not obey arity constraints (see arity) or other semantic constraints (such as argument type constraints; see ArgTypePredicate).  Thus, for example, (genls ?FOO SpatialThing EiffelTower) is a CycL sentence.\n
\nCycLSentences are also called \"logical formulas\", and are to be distinguished from \"denotational formulas\" (which are also known as \"NAT\"s; see CycLNonAtomicTerms).  Note that this notion of a CycL sentence is broader than the notion of \"sentence\" standardly used in formal logic, where a sentence is defined as a closed well-formed formula: CycL sentences may be open (i.e. they may contain free variables; see the specialization CycLOpenSentence)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftRuleAssertion,"The subcollection of semantically well-formed CycLAssertions whose formulas are rules.\nMore precisely, the formulas are not\nGAFs (see CycLGAFAssertion), so they either have more than one literal (and therefore are\nnon-atomic) or they quantify over some free variables (and therefore are non-ground).\nAny free variables are implicitly universally quantified."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftRepresentedTerm,"The collection of all denotational terms that are represented in the CycL language, instead of being defined in SubL, the underlying implementation language used by Cyc.  That is, each instance of CycLRepresentedTerm is either (i) an atomic term, and thus also an instance of CycLRepresentedAtomicTerm (q.v.), or (ii) a non-atomic term (or \"NAT\"), and has a CycLRepresentedTerm as its arg0 functor (the other arguments in the NAT\nneed not be CycL represented terms).  Thus CycLRepresentedTerm has as instances all CycLConstants, all CycLVariables, and all CycLNonAtomicTerms."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftRepresentedAtomicTerm,"A specialization of CycLAtomicTerm.  An instance ATOM of CycLAtomicTerm is also an instance of CycLRepresentedAtomicTerm just in case ATOM is explicitly represented in the CycL language (as opposed to being represented in SubL, the underlying implementation language of the Cyc system).  Important specializations of CycLRepresentedAtomicTerm include CycLVariable and CycLConstant."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftReifiedDenotationalTerm,"The collection of denotational terms in the CycL language which are\nreified in the KB.  Examples include Muffet and (JuvenileFn Dog); a\ncounterexample would be (JuvenileFn Platypus) because that term is not\ncurrently reified in the KB.  These are often called 'FORTs', which stands for\n'first-order reified terms'"),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftReifiableNonAtomicTerm,"A collection of Cyc terms that are NATs (CycLNonAtomicTerms; see\nFunction-Denotational) whose functor is an instance of\nReifiableFunction. E.g., since GovernmentFn is an instance of\nReifiableFunction, it is true that (GovernmentFn France) is a\nCycLReifiableNonAtomicTerm."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftReifiableDenotationalTerm,"A subcollection of both CycLClosedDenotationalTerm and CycLIndexedTerm (qq.v.).  CycLReifiableDenotationalTerm is the collection of all CycL terms that both may be reified and may denote something in the universe of discourse. It thus includes all instances of CycLConstant as well as any NAT (see CycLNonAtomicTerm) whose main functor denotes an instance of ReifiableFunction.\n
\nFor example, the NAT '(GovernmentFn France)' is a CycLReifiableDenotationalTerm, since GovernmentFn is a ReifiableFunction.  Similarly,  '(JuvenileFn Platypus)' is a CycL reifiable denotational term; although it is not currently reified in the KB, it is reifiable and denotational (see CycLClosedDenotationalTerm).  Finally, '(BorderBetweenFn Canada Mexico)' is a CycL reifiable denotational term; although it happens not to denote anything in the universe of discourse, it is nonetheless the kind of NAT that can and usually does denote.\n
\nNote that CycLVariables are not considered reifiable terms."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtReformulationRulePredicate,"The collection of Predicates which may appear as the operator in a CycLReformulatorRule."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftPropositionalSentence,"The collection of CycL sentences that express propositions (see Proposition).  Two necessary conditions for a CycL sentence's expressing a proposition is that it be closed (see CycLClosedSentence) and not violate any applicable arity constraints (see CycLSentence-Askable)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentence,"A specialization of both CycLOpenExpression and CycLSentence. The collection of CycL sentences that contain one or more free variables.  Note that those CycL sentences that are treated (in the context of representing assertions in the Cyc Knowledge Base) as implicitly containing initial universal quantifiers are in fact CycLOpenSentences."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonAtomicTerm,"The collection of denotational CycLNonAtomicTerms that have free variables. Examples: `(JuvenileFn ?X)', `(JuvenileFn ?X ?Y ?Z)'.  Counterexample: `(TheSetOf ?X (objectHasColor ?X GreenColor))'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentence,"A specialization of both CycLOpenExpression and CycLFormula (qq.v.).  The collection of compound CycL expressions that contain one or more free variables."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftCycLOpenExpression,"A specialization of CycLExpression.  The collection of CycL expressions that contain one or more free variables.  A CycLVariable VAR occurs _free_ in an expression EXPR if and only if there is an occurrence of VAR in EXPR that is not bound by another term in EXPR that denotes a Quantifier or other ScopingRelation (q.v.).  For example, the expression `(isa ?X Cat)' is open, but `(thereExists ?X (isa ?X Cat))' is not."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftDenotationalTerm,"The collection of all open denotational terms in the CycL language.  An expression is \"open\" if it contains one or more free variables (see CycLOpenExpression).  A CycL term is said to be \"denotational\" if it is the right sort of term to have a denotation (or value) in the universe of discourse (see CycLDenotationalTerm).  Each instance of CycLOpenDenotationalTerm is either a CycLOpenNonAtomicTerm (i.e. a \"NAT\" with a free variable) or a CycLVariable itself.  Examples include `?X', `(JuvenileFn ?X)', and `(JuvenileFn isa ?X genls JuvenileFn)' (even though the latter is semantically ill-formed)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonAtomicTermAssertible,"A CycLExpressionType and a specialization of both CycLExpression-Assertible and CycLNonAtomicTerm (qq.v.).  The collection of all CycL non-atomic terms that could appear within a sentence that could be asserted to the Cyc Knowledge Base.  More precisely, each instance of CycLNonAtomicTerm-Assertible is a non-atomic term that is both syntactically and semantically well-formed.  By definition, any CycL non-atomic term is syntactically well-formed.  To be semantically well-formed, a non-atomic term sentence must be constructible via the syntax of CycL without violating any applicable arity or argument-type constraints (see arity and ArgTypePredicate).  A CycL term must be semantically well-formed in order to be interpretable as having a \"semantic value\", which for terms means having a denotation.  Note that being \"assertible\" in the present sense does not require a sentence's actually being asserted in the KB."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonAtomicTermAskable,"The collection of CycLNonAtomicTerms\nthat can appear within sentences that are askable as queries to the Cyc system\n(see CycLSentence-Askable).  More precisely, each instance of \nCycLNonAtomicTerm-Askable is a CycL non-atomic term that is constructible via \nthe syntax of CycL without violating any applicable arity constraints (see \narity).  Note that askable CycL non-atomic terms do not necesarily obey other \nsemantic constraints beyond arity, such as argument-type constraints (see \nArgTypePredicate); thus they are not always semantically well-formed in \nthe fullest sense (cf. CycLNonAtomicTerm-Assertible)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonAtomicTerm,"A CycLExpressionType and a specialization of both CycLFormula \nand CycLRepresentedTerm (qq.v.).  CycLNonAtomicTerm is the \ncollection of non-atomic denotational terms in the CycL language.  \nA CycL term is _non-atomic_ if it is constructible from other CycL \nterms via the syntax of CycL.  A CycL term is said to be \n\"denotational\" if it is the type of term that can have a \ndenotatum (or assigned value; see CycLDenotationalTerm).  \nCycLNonAtomicTerm thus includes all CycL denotational terms \nexcept constants and variables.  A CycL non-atomic term (or \"NAT\") \nconsists of a CycL expression denoting a Function-Denotational \nfollowed by one or more CycL terms, with the entire sequence \nenclosed in parentheses.  The NAT itself denotes the value (if any) \nof this function for the denotations of the other terms taken as \narguments.  (If there is no such value then the NAT has no denotatum;\nsee undefined.)  NATs are also known as \"denotational formulas\", \nin contrast to \"logical formulas\" (i.e. sentences).  Currently, \nthere are two main types of NAT: (i) HLNonAtomicReifiedTerms (or \n\"NART\"s), which are a type of HLReifiedDenotationalTerm and are \nimplemented with data structures that have indexing that enables all \nuses of the NAT to be retrieved, and (ii) ELNonAtomicTerms (or \n\"NAUT\"s), which have no such indexing and remain in the \nform of an EL expression in the assertions in which\nthey occur."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftNonAtomicReifiedTerm,"The subcollection of CycLReifiableNonAtomicTerms that are reified in the KB. Example: (JuvenileFn Dog).  Counterexample: (JuvenileFn Platypus), because that term is not currently reified in the KB.  These are often called NARTs, which stands for 'non-atomic reified term'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(mobCyclist,"A specialization of IndividualAgent. Each instance of Cyclist is an agent (usually a person) entitled to inspect and modify the Cyc knowledge base."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftIndexedTerm,"The collection of indexed or indexable terms in the CycL language.\nThis includes reified HL terms as well as reifiable EL NATs and assertions."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftGenericRelationFormula,"A subcollection of CycLFormula (q.v.).  Each instance of that CycLGenericRelationFormula is a CycL formula that begins (immediately after the opening parenthesis) with a variable or other open expression (see CycLOpenExpression); i.e. it has an open expression in its \"0th\" or \"arg0\" position.  A CycL generic relation formula thus consists \nof an open expression followed by some number of terms, with the entire sequence \nenclosed in parentheses.  But note that the open expression in the formula's \narg0 position must be such that, given the syntax and intended semantics of CycL, it could conceivably have a Relation -- i.e. a Function-Denotational or a TruthFunction (such as a Predicate or LogicalConnective) -- as its semantic value.  Hence the arg0 open expression might be a variable, as in the generic relation formula `(?RELATION Muffet Dog)'; or it might be an appropriate open non-atomic term (or \"NAT\"; see CycLNonAtomicTerm), as in \n`((Kappa (?ARG1) (knows ?ARG1 ?ARG2)) Muffet)'; or it might itself be \na generic relation formula, as in `((?REL ?ARG1 Dog) Muffet)'.  On the \nother hand, `((BorderBetweenFn ?ARG1 ?ARG2) Muffet Dog)' is not a \nCycLGenericRelationFormula, since BorderBetweenFn only returns instances \nof Border, which is disjoint with Relation; thus the open NAT \n`(BorderBetweenFn ?ARG1 ?ARG2)' couldn't possibly have a Relation as its \nsemantic value, no matter what values were assigned to the variables `?ARG1' \nand `?ARG2'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftGAFAssertion,"A CycLExpressionType and a specialization of both CycLAtomicAssertion and CycLClosedAtomicSentence (qq.v.).  This is the collection of all and only the closed atomic CycL sentences that have been asserted to the Knowledge Base or deduced there by the inference engine.  GAF assertions typically express particular facts (as opposed to general rules) about the world.  The acronym `GAF' stands for \"ground atomic formula\"; see CycLClosedAtomicSentence.\n
\nAt the epistemological level (see ELExpression), a GAF assertion contains no free variables and is thus (at least) \"ground\".  At the heuristic level (see HLExpression), however, the HLAssertion(s) representing the GAF assertion -- the sentence(s) that are actually stored in the KB -- contain no variables whatsoever and are thus \"_fully_ ground\" (see CycLFullyGroundAtomicSentence).  For example, if the ground atomic sentence\n
\n(isa (TheSetOf ?X (objectHasColor ?X GreenColor)) Thing)\n
\nwere asserted it would be a GAF assertion, and it would be represented in the KB by some fully ground atomic sentence(s) containing no variables at all."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftSentence,"The collection of compound CycL expressions.  Each instance of CycLFormula consists of a CycL expression that denotes a relation (e.g. a Predicate, Function-Denotational, or TruthFunction) -- or at least an expression that could be interpreted as having a relation as its semantic value (see CycLGenericRelationFormula) -- followed by one or more CycL terms (see CycLTerm), with the entire sequence enclosed in parentheses.  For example, (isa Muffet Poodle) and (BirthFn Muffet) are both CycL formulas.  Two important specializations of CycLFormula are CycLNonAtomicTerm (whose instances are also called \"denotational formulas\") and CycLSentences (whose instances are also called \"logical formulas\").  Note that this notion of \"formula\" differs somewhat from that used in formal logic, where a formula is normally defined as an (atomic or non-atomic, quantificationally closed or open) sentence."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ttExpressionType,"A collection of collections.  Each instance of CycLExpressionType is a type (i.e. a subcollection) of CycLExpression.  Note that, while CycLExpressionType is not itself a quotedCollection (q.v.), most of its reified instances are quoted-collections."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftExpressionAssertible,"A CycLExpressionType.  The collection  of all compound CycL expressions that either could themselves be asserted to the  Cyc Knowledge Base (see CycLSentence-Assertible) or could appear as denotational terms within sentences that could be so asserted (see CycLDenotationalTerm-Assertible).  More precisely, each instance of CycLExpression-Assertible is a CycL expression that is both syntactically and semantically well-formed.  By definition, any compound CycL expression is  syntactically well-formed.  To be semantically well-formed, a CycL expression  must be constructible via the syntax of CycL without violating any applicable arity or argument-type constraints (see arity and ArgTypePredicate).  A CycL expression must be semantically well-formed in order to be interpretable as having a \"semantic value\", such as a truth-value (if the expression is a sentence) or a denotation (if it's a CycLDenotationalTerm).  Note that being \"assertible\" in the present sense does not require an expression's actually being asserted in (or being a component of something asserted in) the KB."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftExpressionAskable,"The collection of CycLExpressions\nthat are either themselves askable as queries to the Cyc system (see \nCycLSentence-Askable) or could appear as non-atomic terms within \nsentences that could be so asked (see CycLNonAtomicTerm-Askable). \nMore precisely, each instance of CycLExpression-Askable is a CycL \nexpression that is constructible via the syntax of CycL without \nviolating any applicable arity constraints (see arity).  Note that \naskable CycL expressions do not necesarily obey other semantic \nconstraints beyond arity, such as argument-type constraints (see \nArgTypePredicate); thus they are not always semantically \nwell-formed in the fullest sense (cf. CycLExpression-Assertible)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftCycLExpression,"The collection of all (and only) expressions in the CycL language.  This includes all constants, variables, and formulas (i.e. non-atomic terms and sentences).  Each CycL expression is, trivially, a syntactically well-formed expression of CycL; but note that it might or might not be \"semantically well-formed\" (see CycLExpression-Assertible).  Also note that, since the CycL syntax allows any CycL expression to be used as a term, CycLExpression is coextensional with CycLTerm (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftDenotationalTermAssertible,"A CycLExpressionType and a specialization of both CycLDenotationalTerm and CycLExpression-Assertible (qq.v.).  This is the collection of all CycL denotational terms that could appear within a sentence that could be asserted to the Cyc Knowledge Base.  More precisely, each instance of CycLDenotationalTerm-Assertible is a denotational (i.e. non-logical) term that is both syntactically and semantically well-formed.  By definition, any CycL term is syntactically well-formed.  To be semantically well-formed, denotational term sentence must be either be atomic (see CycLAtomicTerm) or constructible via the syntax of CycL (see CycLNonAtomicTerm-Assertible) without violating any applicable arity or argument-type constraints (see arity and ArgTypePredicate).  A CycL term must be semantically well-formed in order to be interpretable as having a \"semantic value\", which for denotational terms means having a denotation.  Note that being \"assertible\" in the present sense does not require a sentence's actually being asserted in the KB."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftDenotationalTerm,"The collection of all CycL terms that are not sentences (cf. CycLSentence), and thus are either CycLAtomicTerms (such as constants or variables) or CycLNonAtomicTerms (also known as \"NAT\"s).   CycLDenotationalTerms are so-called, not because they all have denotations (not all of them do), but because they are in a certain sense the right kind of term for having a denotation.  That is, an instance of CycLDenotationalTerm -- if it is semantically well-formed and closed (i.e. contains no free variables) -- might denote something in the universe of discourse.  (Even so, it will not _necessarily_ denote something, considering (e.g.) the fact that a function need not be defined for every (sequence of) thing(s) satisfying its argument type constraints; see PartialFunction.)  But note that neither semantic well-formedness nor being closed is a requirement for being a CycL denotational term: `(JuvenileFn isa ?X genls JuvenileFn)', for example, is a NAT and thus a denotational term.  Other examples of denotational terms are the expressions: `Muffet', `?X', `(JuvenileFn ?X)', `(TheSetOf ?X (objectHasColor ?X GreenColor))', and `212'.  Note also that, like most instances of CycLExpressionType, CycLDenotationalTerm is a quotedCollection (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftDeducedAssertion,"The subcollection of semantically well-formed CycLAssertions that are supported by at least one argument which is a deduction by Cyc's inference engine, as opposed to having been explicitly asserted to Cyc. A given assertion can have more than one argument, and can therefore be both a CycLAssertedAssertion and a CycLDeducedAssertion."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftConstant,"The collection of all constants in the CycL language. CycLConstant has as instances all CycLAtomicTerms other than CycLVariables and SubLAtomicTerms (qq.v.).  Orthographically, CycL constants are those atomic terms (i.e. terms not constructable from other terms via CycL syntax) that are prefixed by '' in their printed (as opposed to their HTML-displayed) representations.  For example, 'Dog' and 'isa' are CycL constants, while other CycL terms like '?X', '42', and  '(GovernmentFn France)' are not."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftClosedSentence,"A specialization of both CycLSentence and CycLClosedExpression.  The collection of CycL sentences that contain no free variables.  Note that those CycL sentences that are treated (in the context of representing assertions in the Cyc Knowledge Base) as implicitly containing universal quantifiers are not closed sentences (cf. CycLOpenSentence)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftClosedNonAtomicTerm,"The collection of closed, non-atomic denotational terms of the CycL language.  Each instance of CycLClosedNonAtomicTerm is a CycL term that contains no free variables, is constructible from other CycL terms via the syntax of CycL, and can have a denotatum (this last requirement excludes closed CycL sentences from CycLClosedNonAtomicTerm).  Examples: `(JuvenileFn Platypus)', `(JuvenileFn isa genls)', and `(TheSetOf ?X (objectHasColor ?X GreenColor))'.  Non-example: `(JuvenileFn ?X)'."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftClosedFormula,"A specialization of both CycLFormula and CycLClosedExpression.  The collection of compound expressions of CycL that contain no free variables."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftCycLClosedExpression,"The collection of CycLExpressions that contain no free variables.  (A variable VAR occurs _free_ in an expression EXPR if and only if there is an occurrence of VAR in EXPR that is not bound by a quantifier or other ScopingRelation (q.v.) in EXPR.)  Note that those CycL sentences that are treated (in the context of representing assertions in the Cyc Knowledge Base) as implicitly containing universal quantifiers are _not_ closed expressions (see CycLClosedSentence). Also cf. CycLOpenExpression."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftClosedDenotationalTerm,"The collection of all closed denotational terms in the CycL language.  An expression is said to be \"closed\" if it contains no free variables (see CycLClosedExpression).  A CycL term is said to be \"denotational\" if it is the right sort of term to have a denotation (or value) in the universe of discourse (see CycLDenotationalTerm).  CycL sentences, while terms of CycL, are not considered denotational terms.  Each instance of CycLClosedDenotationalTerm is either a CycLClosedAtomicTerm (i.e. a CycLConstant or SubLAtomicTerm) or a CycLClosedNonAtomicTerm (i.e. a \"NAT\" with no free variables).  Examples of closed denotational terms include `Muffet', `(JuvenileFn Dog)', `(TheSetOf ?X (objectHasColor ?X GreenColor))', and `212'.  Note that these are also examples: `(BorderBetweenFn Canada Mexico)' (despite the fact that it fails actually to denote anything) and `(JuvenileFn isa genls JuvenileFn)'\n(despite the fact that it is not semantically well-formed)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAtomicTerm,"The collection of all closed CycLAtomicTerms.  \"Closed\" here means not containing any free (i.e. unbound) variables.  Since a variable itself is the only type of _atomic_ term that contains a variable (and contains it _free_, moreover, as a single occurrence of a variable can't bind itself), CycLClosedAtomicTerm has as instances all CycLAtomicTerms except CycLVariables.  Like all CycL atomic terms, Cycl closed atomic terms are \"denotational\" (see CycLDenotationalTerm).  Note that this collection, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftClosedAtomicSentence,"A CycLExpressionType and a specialization of both CycLAtomicSentence and CycLClosedSentence (qq.v.).  This is the collection of all and only the syntactically well-formed atomic sentences in the CycL language that contain no free variables.  Syntactically, each instance of CycLClosedAtomicSentence consists of a CycL expression denoting a Predicate followed by one or more (closed) CycL terms, with the entire sequence enclosed in parentheses.  Such sentences are sometimes called \"GAFs\" (an acronym for \"ground atomic formulas\"); see also the specialization CycLFullyGroundAtomicSentence."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAtomicTerm,"The collection of all atomic CycLDenotationalTerms (q.v.).  \"Atomic\" here means not constructible  from other CycL terms via the syntax of CycL.  Thus, subcollections  of CycLAtomicTerm include CycLConstant, CycLVariable, and SubLAtomicTerm.  Note that CycLAtomicTerm, like most instances of CycLExpressionType, is \"quoted\" (see quotedCollection)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAtomicSentence,"The collection of syntactically well-formed atomic sentences in the CycL language. Each instance of CycLAtomicSentence consists of a CycL constant denoting a Predicate followed by one or more (closed or open) CycL terms, with the entire sequence enclosed in parentheses.  Thus CycL atomic sentences never contain other sentences as truth-functional components (see TruthFunction).  Note that \"atomic\" as used here specifically in connection with _sentences_, has a less strict meaning than it does when applied to terms generally, where it means \"not constructible from other terms via CycL syntax\" (see CycLAtomicTerm)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAtomicAssertion,"A specialization of CycLAtomicSentence.  An instance ATOM of CycLAtomicSentence is also an instance of CycLAtomicAssertion just in case ATOM has been explicitly asserted to the Cyc Knowledge Base (see CycLAssertedAssertion), or deduced in the Knowledge Base by the Cyc inference engine (see CycLDeducedAssertion)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAssertion,"The collection of semantically well-formed CycLSentences asserted to the Cyc Knowledge Base.  Each instance of CycLAssertion is either (1) an HL assertion, i.e. a CycL sentence that corresponds to a data structure actually in the Cyc KB), or (2) an EL assertion : an Epistemological Level CycL sentence that can be canonicalized into one or more already extant HL assertions.  CycLAssertion is used as a quoted argument type constraint for certain meta-predicates, such as overrides."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(ftAssertedAssertion,"A specialization of CycLAssertion.  An instance ASSERT of CycLAssertion is also an instance of CycLAssertedAssertion  just in case ASSERT was explicitly asserted to the Cyc Knowledge Base by one of its users (see the collection Cyclist), as opposed to having been deduced by Cyc's inference engine (in which case it would be an instance of CycLDeducedAssertion (q.v.)).  Note that since a single assertion can be both explicitly asserted to the knowledge base and also deduced by the inference engine, the collections CycLAssertedAssertion and CycLDeducedAssertion are not disjoint."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tCycHLSupportDatastructure,"A specialization of both CycHLDatastructure and\nCycSupportDatastructure (qq.v.) instances of which\nare Cyc HL datastructures that can be used as supports\nwithin a CycDeductionDatastructure (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtCommutativeRelation,"An instance of RelationTypeByLogicalFeature (q.v.) and a specialization of AtLeastPartiallyCommutativeRelation (q.v.).  Each instance of CommutativeRelation COMRELN is a predicate or function that is commutative in all of its argument-places.  That is, if COMRELN is a predicate (function) that holds among (has a value VAL for) a given sequence of arguments, then COMRELN also holds among (has the same value VAL for) any permutation of that  sequence.  \n
\nExamples of commutative relations include PlusFn, or, bordersOn, temporallyIntersects, and teammates.  Specialization include SymmetricBinaryPredicate.  \n
\nNote that most relations are not commutative.  Cf. the disjoint collection  PartiallyCommutativeRelation."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(tCol,"A specialization of SetOrCollection (q.v.).  This is the collection of all collections of things.  Each Collection is a kind or type of thing whose instances share a certain property, attribute, or feature.  For example, Cat is the collection of all and only cats, and BinaryFunction is the collection of all and only functions taking two arguments.\n
\nThe notion of collection is fundamental to the Cyc ontology, and is thus difficult to define in a precise and substantive way.  But it is instructive to compare it to the mathematical notion of a set (see Set-Mathematical).  Like a set, a collection is an AbstractThing (i.e. aspatial and atemporal) that is not an Individual (cf.), but instead has elements (see elementOf).  Unlike a set, however, the elements or \"instances\" (see isa) of a given collection can vary from context to context, and it is possible for distinct collections to have exactly the same elements (i.e. to have the same extent) with respect to a given context. For example, the (non-reified) collections \"Chordate\" and \"Renate\" are co-extensional in the context of the present-day actual world, but have differring extents with respect to hypothetical contexts in which there exist creatures having hearts but not kidneys.  This difference is sometimes summarized by saying that sets are \"extensional\" things and collections are \"intensional\" things.\n
\nMany, though by no means all, of the collections reified in the Cyc ontology correspond to natural kinds or classes.  It is particulary useful to reify collections that are difficult to define precisely, but about which there are many common-sense rules and other things to state.  For example, it would not be worthwile to introduce a constant 'WhiteCat', both because it's easy to define the collection of white cats in terms of more general, already-reified notions (e.g. '(CollectionIntersection2Fn Cat WhiteColor)'), and because there's not much to say about that particular collection.  WhiteCollarWorker, on the other hand, is a good collection to have reified, as it is hard to define precisely, yet is a collection about which there are many things to say.\n
\nSome of the many reified specializations of Collection are FirstOrderCollection, TimeDependentCollection, and ObjectType."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(mtBroadMicrotheory,"The collection of those microtheories that contain so many assertions that they are not useful for `relevance' focusing during inference.  (A BroadMicrotheory is not used internally in Cyc's indexing scheme during inference.)  Examples: BaseKB and EnglishMt."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtBookkeepingPredicate,"A PredicateType whose instances are predicates used to make assertions about the reification (or \"creation\") and internal representation of particular CycL terms (usually constants) in the Cyc system.  Bookkeeping predicates neither specify nor constrain the semantics of CycL terms.  Examples include  myCreator, myCreationTime, termOfUnit, and defnSufficient.  Many (but not all) bookkeeping predicates are also MetaKnowledgePredicates (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtBinaryPredicate,"A specialization of both BinaryRelation and Predicate.  BinaryPredicate is the collection of all predicates whose arity (see arity) is 2."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtBinaryFunction,"A specialization of both BinaryRelation and Function-Denotational.  An instance of Function-Denotational FUNC is an instance of BinaryFunction if and only if FUNC has an arity of 2."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vAverageFn,"Computes the average of the function values over all elements in the Set."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vAugust,"The collection of all Augusts,\n the eighth month of the year in the GregorianCalendar."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtAsymmetricBinaryPredicate,"An instance of BinaryPredicateTypeByLogicalFeature and a specialization of AntiSymmetricBinaryPredicate (q.v.).  A binary predicate BINPRED is an instance of AsymmetricBinaryPredicate if and only if (i) for any THING1 and THING2, (BINPRED THING1 THING2) implies (not (BINPRED THING2 THING1)) and (ii) the single-argument argument type (i.e. argIsa and argGenl) constraints on BINPRED's two respective argument-places are \"co-satisfiable\" (see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement).\n
\nExamples of asymmetric binary predicates include northOf, children, greaterThan, and overrides.  Cf. SymmetricBinaryPredicate."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgTypeTernaryPredicate,"Those instances of both TernaryPredicate and ArgTypePredicate used to specify the required isa or genls or quotedIsa of an argument of a Relation; the arg1 is the Relation; the arg2 is the argument constrained; the arg3 is the required type: a Collection."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgTypePredicate,"The collection of ArgConstraintPredicates used to put semantic well-formedness constraints on the type of argument(s) appropriate for a given argument-place (or -places) of a given relation.  A \"type\" of argument can be specified in terms of isa or genls; see the various specializations of ArgTypePredicate for more detail. Violation of such a constraint results in an expression that is semantically malformed.  For a general explanation of semantic well-formedness, see CycLExpression-Assertible and its specializations."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgTypeBinaryPredicate,"Those instances of both BinaryPredicate and ArgTypePredicate used to specify the required isa or genls or quotedIsa of an argument of a Relation; the arg1 is the Relation; the arg2 is the required type, a Collection."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgIsaTernaryPredicate,"A specialization of both ArgTypeTernaryPredicate and ArgIsaPredicate (q.v.).  Each instance of ArgIsaTernaryPredicate is a ternary predicate used to place an \"isa\" constraint on (and thereby specify an argument-type for) one or more argument-places of a relation.  To be more precise, each instance PRED of ArgIsaTernaryPredicate takes a Relation RELN as its first argument, a NonNegativeInteger N as its second argument, and a Collection COL as its third argument.  PRED places an \"isa\" constraint on RELN's Nth argument-place that is based on COL, so that a ground atomic sentence (GAF) of the form (RELN ARG1..ARGN..) is semantically well-formed only if ARGN is an instance of COL. (Note that (i) if N = 0 then this same constraint is placed on _all_ of RELN's argument-places and (ii) if PRED is argAndRestIsa then this constraint is placed on all of RELN's argument-places whose ordinal positions are greater than or equal to the Nth.)  An important instance of ArgIsaTernaryPredicate is argIsa."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgIsaPredicate,"The collection of ArgTypePredicates (q.v.) that specify argument-types directly (by referencing certain collections) and impose constraints that require a thing's being an instance of a collection thus specified.  More precisely, each instance of ArgIsaPredicate PRED takes a Relation RELN as its first argument (or \"arg1\"), and has at least one other argument-place (say the Mth) for specifying an argument-type for one of RELN's argument-places (say the Nth).  (The value of N might be fixed or might be given by yet another of PRED's arguments.)  Suppose M=2 and N=1.  PRED then takes a Collection as its second argument, and a closed atomic sentence (or \"GAF\") of the form (PRED RELN COL ..) puts an \"isa\" constraint on RELN's first argument-place that is based on COL.  If PRED is a \"single-argument\" constraint predicate, the GAF entails that a closed formula of the form (RELN ARG1 ..) is semantically well-formed only if ARG1 is an instance of (i.e. isa) COL.  If PRED is an \"inter-argument\" constraint predicate, the GAF expresses a slightly more complicated, conditional isa constraint on a pair of RELN's argument-places (see InterArgIsaPredicate)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgIsaBinaryPredicate,"A specialization of both ArgTypeBinaryPredicate and ArgIsaPredicate.  Each instance of ArgIsaBinaryPredicate takes a Relation RELN as its first argument, and a Collection COL as its second argument, and places a constraint based on COL on at least one of the argument-places of RELN.  To be more precise, suppose that PRED is an ArgIsaBinaryPredicate that specifies an argument-type for the Nth argument-place of RELN.  Then a sentence of the form (PRED RELN COL) entails that a closed formula of the form (RELN ... ARGN ...) is semantically well-formed only if  ARGN is an instance of COL."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgGenlTernaryPredicate,"A specialization of ArgTypeTernaryPredicate and ArgGenlPredicate.  Each instance of ArgGenlTernaryPredicate is used to specify that a certain collection is required to stand in the genls relation to anything that is acceptable in a particular argument slot of a given instance of Relation.  With each instance of ArgGenlTernaryPredicate, the first argument is the relation constrained; the second argument is the argument constrained; and the third argument is the required collection that the relation's specified argument is required to be a specialization of."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgGenlQuantityTernaryPredicate,"A specialization of both ArgTypeTernaryPredicate and ArgGenlAttributePredicate.  Each instance of ArgGenlAttributeTernaryPredicate is a ternary predicate used to place a \"quantitySubsumes\" constraint on (and thereby specify an argument-type for) one or more argument-places of a relation.  To be more precise, each instance PRED of ArgGenlAttributeTernaryPredicate takes a Relation RELN as its first argument, a NonNegativeInteger N as its second argument, and an Quantity QUANT as its third argument. PRED places a \"quantitySubsumes\" constraint on RELN's Nth argument-place that is based on QUANT, so that a ground atomic sentence (GAF) of the form (RELN ARG1..ARGN..) is semantically well-formed only if ARGN is subsumed by QUANT (in the sense that (quantitySubsumes QUANT ARGN) holds).  An important instance of ArgGenlAttributeTernaryPredicate is argGenlAttribute."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgGenlQuantityBinaryPredicate,"Those instances of both ArgTypeBinaryPredicate and ArgGenlAttributePredicate used to specify the required quantity of an argument of Relation.  Each instance PRED of this collection is a binary predicate with the following properties: ARG1 is an instance of Relation, and ARG2 is an instance of Quantity.  (PRED ARG1 ARG2) means that some argument of ARG1 is constrained to be subsumed by (via quantitySubsumes) ARG2, where PRED determines the argument place in question."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgGenlBinaryPredicate,"Those instances of both BinaryPredicate and ArgGenlPredicate used to specify the required genls of an argument of a Relation; the arg1 is the Relation; the arg2 is the required genls Collection."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtArgConstraintPredicate,"The collection of MetaRelations whose instances are used to put semantic well-formedness or entry-format constraints on one or more argument-places of a given Relation.  Such a constraint might concern an argument's type, an argument-place's Format (q.v.), a conditional relationship between two argument(-place)s' types or formats, or some other sort of relationship between two arguments.  For a fuller account, see the various specializations of ArgConstraintPredicate."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vApril,"The collection of all Aprils, \nthe fourth month of the year in the GregorianCalendar."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtAntiTransitiveBinaryPredicate,"A BinaryPredicateTypeByLogicalFeature and a specialization of  IrreflexiveBinaryPredicate (q.v.).  A binary predicate PRED is an instance of  AntiTransitiveBinaryPredicate only if it has this property: for any THING1, THING2, and THING3 such that both (PRED THING1 THING2) and (PRED THING2 THING3) hold, (not (PRED THING1 THING3)) holds.  Equivalently: for every X, Y, and Z that satisfy the (single-argument) argument-type constraints  (see admittedArgument) for the relevant argument positions of PRED,  (not (and (PRED X Y)(PRED Y Z)(PRED X Z))) holds.  Note that  PRED's two agument-positions must also be \"co-satisfiable\" with respect to their type constraints; see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement.\n
\nFor example, divorcedFrom is an instance of AntiTransitiveBinaryPredicate.\n
\nNote also that, while not strictly disjoint with TransitiveBinaryPredicate (q.v.), in practice few if any reified predicates should be instances of both of these collections. An important specialization of AntiTransitiveBinaryPredicate is DirectBinaryPredicate (q.v.)."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(rtAntiSymmetricBinaryPredicate,"A BinaryPredicateTypeByLogicalFeature and thus a specialization of BinaryPredicate.  A binary predicate PRED is an AntiSymmetricBinaryPredicate if and only if it has the following two properties.  (i) For any THING1 and THING2 such that both (PRED THING1 THING2) and (PRED THING2 THING1) hold, THING1  = THING2.  (ii) PRED's two argument-places must be \"co-satisfiable\" with respect to their (single-argument) type constraints (see cosatisfiableInArgs and NoteOnArgumentCosatisfiabilityRequirement).\n
\nInstances of AntiSymmetricBinaryPredicate include greaterThanOrEqualTo, parts, and subEvents.  See also the specialization AsymmetricBinaryPredicate; and cf. SymmetricBinaryPredicate."),iUniversalVocabularyMt,vStrDef).
tiny_kb(comment(vAbsoluteValueFn,"AbsoluteValueFn is the unary mathematical function that returns the absolute value of its argument; e.g., (AbsoluteValueFn -2) returns 2, and (AbsoluteValueFn 2) returns 2."),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(ttUnitOfMeasure(UNIT),unitMultiplicationFactor(UNIT,UNIT,1)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(omitArgIsa(RELN,N),abnormal(vTheListFn(Q_COL,COL,RELN,N),'TINYKB-ASSERTION'(':TRUE-DEF',[[[genlsSpecdenotesgenlinstances,Q_COL,COL],[argQuotedIsa,RELN,N,Q_COL]],[[argIsa,RELN,N,COL]]],iUniversalVocabularyMt,s("?Q-COL","?COL","?RELN","?N"),[implies,[and,[genlsSpecdenotesgenlinstances,Q_COL,COL],[argQuotedIsa,RELN,N,Q_COL]],[argIsa,RELN,N,COL]]))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(ist(mtMtSpaceFn(MT),SENTENCE),ist(MT,SENTENCE)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(rewriteOf(REWRITE,TERM),t(PRED,ARG1,TERM,ARG3)),t(PRED,ARG1,REWRITE,ARG3)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(rewriteOf(REWRITE,TERM),t(PRED,ARG1,TERM)),t(PRED,ARG1,REWRITE)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(ist(MT,SENTENCE),ist(mtMtSpaceFn(MT),SENTENCE)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(assertionUtility(ASSERTION,1),highlyRelevantAssertion(ASSERTION)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(irrelevantAssertion(ASSERTION),assertionUtility_1(ASSERTION,-1)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(assertionUtility_1(ASSERTION,1),highlyRelevantAssertion(ASSERTION)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(assertionUtility_1(ASSERTION,-1),irrelevantAssertion(ASSERTION)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(highlyRelevantAssertion(ASSERTION),assertionUtility(ASSERTION,1)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(highlyRelevantAssertion(ASSERTION),assertionUtility_1(ASSERTION,1)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(call_u_no_bc(genls(TERM,INDEP_COLL)),meetsPragmaticRequirement(vTheListFn(NAT,FUNC,NUM,INDEP_COLL_NAT,TERM,INDEP_COLL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[natFunction,NAT,FUNC],[preservesGenlsInArg,FUNC,NUM],[natFunction,INDEP_COLL_NAT,FUNC],[genls,TERM,INDEP_COLL],[natArgument,NAT,NUM,TERM],[natArgument,INDEP_COLL_NAT,NUM,INDEP_COLL]],[[genls,NAT,INDEP_COLL_NAT]]],iUniversalVocabularyMt,s("?NAT","?FUNC","?NUM","?INDEP-COLL-NAT","?TERM","?INDEP-COLL"),[implies,[and,[natFunction,NAT,FUNC],[preservesGenlsInArg,FUNC,NUM],[natFunction,INDEP_COLL_NAT,FUNC],[genls,TERM,INDEP_COLL],[natArgument,NAT,NUM,TERM],[natArgument,INDEP_COLL_NAT,NUM,INDEP_COLL]],[genls,NAT,INDEP_COLL_NAT]]))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(call_u_no_bc(collectionIsaBackchainRequired(PRED)),meetsPragmaticRequirement(vTheListFn(PRED),'TINYKB-ASSERTION'(':TRUE-DEF',[[[collectionIsaBackchainRequired,PRED]],[[collectionIsaBackchainEncouraged,PRED]]],iUniversalVocabularyMt,s("?","PRED"),[implies,[collectionIsaBackchainRequired,PRED],[collectionIsaBackchainEncouraged,PRED]]))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(call_u_no_bc(collectionGenlsBackchainRequired(PRED)),meetsPragmaticRequirement(vTheListFn(PRED),'TINYKB-ASSERTION'(':TRUE-DEF',[[[collectionGenlsBackchainRequired,PRED]],[[collectionGenlsBackchainEncouraged,PRED]]],iUniversalVocabularyMt,s("?","PRED"),[implies,[collectionGenlsBackchainRequired,PRED],[collectionGenlsBackchainEncouraged,PRED]]))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(call_u_no_bc(collectionBackchainRequired(PRED)),meetsPragmaticRequirement(vTheListFn(PRED),'TINYKB-ASSERTION'(':TRUE-DEF',[[[collectionBackchainRequired,PRED]],[[collectionBackchainEncouraged,PRED]]],iUniversalVocabularyMt,s("?","PRED"),[implies,[collectionBackchainRequired,PRED],[collectionBackchainEncouraged,PRED]]))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(ist(MT,not(numericallyEquals(M,N))),ist(MT,relationAllExistsCount(REL,COL1,COL2,N))),ist(MT,not(relationAllExistsCount(REL,COL1,COL2,M)))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(SMALLER_UNIT),ttUnitOfMeasure(LARGER_UNIT),unitMultiplicationFactor(SMALLER_UNIT,LARGER_UNIT,N)),equals(isa(1,LARGER_UNIT),isa(N,SMALLER_UNIT))),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(PRED),interArgIsa(PRED,2,COL,1,COL)),interArgIsa(PRED,1,COL,2,COL)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(PRED),interArgIsa(PRED,1,COL,2,COL)),interArgIsa(PRED,2,COL,1,COL)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(arity(PRED1,ARITY),arity(PRED2,ARITY),disjointWith(TYPE1,TYPE2),argIsa(PRED1,ARG,TYPE1),argIsa(PRED2,ARG,TYPE2)),negationPreds(PRED1,PRED2)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(greaterThan(BIGGER,SMALLER),relationAllInstance(greaterThanOrEqualTo,COL,BIGGER)),relationAllInstance(greaterThan,COL,SMALLER)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(genls(ARGS_5,ARGS_6),genls(ARGS_6,ARGS_5)),coExtensional(ARGS_5,ARGS_6)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(evaluationResultQuotedIsa(FUNCTION,Q_COL),genlsSpecdenotesgenlinstances(Q_COL,COL)),resultIsa(FUNCTION,COL)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(evaluateImmediately(FUNC),evaluateAtEL(FUNC)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(argFormat(GENLPRED,1,vSingleEntry),different(GENLPRED,SPECPRED),genlPreds(SPECPRED,GENLPRED)),argFormat(SPECPRED,1,vSingleEntry)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(and(genlsSpecdenotesgenlinstances(Q_COL,COL),argQuotedIsa(RELN,N,Q_COL)),argIsa(RELN,N,COL)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(sentenceTruth(SENT,vTrue),trueSentence(SENT)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(genlMt(SPEC,GENL),'NART'('NART'([mtMtUnionFn,SPEC|OTHER_MTS]),GENL)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(elementOf(MT_DIM,'NART'([tSetOfTheSetFn|MT_DIMS])),genlMt('NART'([mtMtSpaceFn|MT_DIMS]),MT_DIM)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(ist('NART'([mtMtSpaceFn|OTHER_MT_DIMS]),SENTENCE),ist('NART'([mtMtSpaceFn,MT_DIM|OTHER_MT_DIMS]),SENTENCE)),iUniversalVocabularyMt,vStrDef).
tiny_kb(implies(ist('NART'([mtMtSpaceFn,MT_DIM|OTHER_MT_DIMS]),SENTENCE),ist('NART'([mtMtSpaceFn|OTHER_MT_DIMS]),SENTENCE)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(quotedIsa(thereExistExactly,ftInferenceSupportedTerm)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(quotedIsa(thereExistAtMost,ftInferenceSupportedTerm)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(quotedIsa(thereExistAtLeast,ftInferenceSupportedTerm)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(quotedIsa(vFalse,ftSentenceAssertible)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(subsetOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(subsetOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(siblingDisjointExceptions)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(quotedIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(quotedIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(quotedIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtInferenceSupportedPredicate(quotedDefnSufficient)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtInferenceSupportedPredicate(quotedDefnNecessary)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtInferenceSupportedPredicate(quotedDefnIff)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(quantityIntersects)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(quantityIntersects)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(negationPreds)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(negationInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(negationInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtInferenceSupportedPredicate(knownAntecedentRule)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(isa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(isa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(isa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(genls)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAsymmetricBinaryPredicate(genls)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genls)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genlPreds)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genlMt)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAsymmetricBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genlInverse)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(evaluationResultQuotedIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(evaluate)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAsymmetricBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(elementOf)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(disjointWith)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtIrreflexiveBinaryPredicate(disjointWith)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(disjointWith)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(constraint)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(conceptuallyRelated)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(conceptuallyRelated)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg6SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg5SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg4SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg3SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg2SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(arg1SometimesIsa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(tWFFSupportedTerm(vIntervalEntry)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAsymmetricBinaryPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genlsSpecdenotesgenlinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtWFFSupportedPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtTransitiveBinaryPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtSymmetricBinaryPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtReflexiveBinaryPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAsymmetricBinaryPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(rtAntiSymmetricBinaryPredicate(genlsGenldenotesspecinstances)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(genls(rtCommutativeRelation,rtPartiallyCommutativeRelation)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(genls(rtCollectionDenotingFunction,rtReifiableFunction)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(genlPreds(reformulatorEquals,equals)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(genlPreds(hlPrototypicalInstance,isa)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(argIsa(evaluate,2,ftNonAtomicTermAskable)),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(and(omitArgIsa(RELN,N),argIsa(RELN,N,_THING))),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(and(notAssertible(PRED),rtDistributingMetaKnowledgePredicate(PRED))),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(and(backchainForbiddenWhenUnboundInArg(PRED,N),arity(PRED,M),greaterThan(N,M))),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(termDependsOn),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(termChosen),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(resultIsaArgIsa),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(quotedArgument),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(pragmaticRequirement),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(performSubL),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(operatorFormulas),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(omitArgIsa),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(natFunction),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(natArgumentsEqual),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(natArgument),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(myCreationPurpose),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(instanceElementType),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(hypotheticalTerm),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(formulaArity),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(exactlyAssertedEL_next),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(evaluate),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(equalSymbols),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(elInverse),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(definingMt),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycTransformationProofRule),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycTransformationProofBindings),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreTerms),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreProofCount),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreProblems),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreProblemCount),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreLinkCount),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemStoreInferenceCount),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemQueryTerms),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemQuerySentence),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(cycProblemProvabilityStatus),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(constantName),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(constantID),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(constantGUID),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(comment),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(collectionIsaBackchainRequired),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(collectionIsaBackchainEncouraged),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(collectionGenlsBackchainRequired),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(collectionGenlsBackchainEncouraged),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(collectionBackchainEncouraged),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(backchainRequired),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(backchainForbiddenWhenUnboundInArg),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(backchainForbidden),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(assertionDirection),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(assertedTermSentences),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(call_u_no_bc),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(assertedPredicateArg),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(admittedSentence),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(admittedArgument),iUniversalVocabularyMt,vStrDef).
tiny_kb(backchainForbidden(istAsserted),iUniversalVocabularyMt,vStrDef).
tiny_kb(notAssertibleCollection(rtELRelation),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(termOfUnit),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(natFunction),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(isa),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(genls),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(genlPreds),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(equals),iUniversalVocabularyMt,vStrDef).
tiny_kb(minimizeExtent(abnormal),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(rtSententialRelation),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(rtQuantifier),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(rtLogicalConnective),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(tHumanCyclist),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(vExistentialQuantifierBounded),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(vtDayOfWeekType),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(vtProvabilityStatus),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(vtInferenceProblemLinkStatus),iUniversalVocabularyMt,vStrDef).
tiny_kb(completelyEnumerableCollection(ttAtemporalNecessarilyEssentialCollectionType),iUniversalVocabularyMt,vStrDef).
tiny_kb(completeExtentEnumerable(termDependsOn),iUniversalVocabularyMt,vStrDef).
tiny_kb(completeExtentAsserted(omitArgIsa),iUniversalVocabularyMt,vStrDef).
tiny_kb(completeExtentAsserted(elInverse),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(and(trueSentence(VALUE),equals(vFalse,VALUE))),iUniversalVocabularyMt,vStrDef).
tiny_kb(not(and(trueSentence(SENT),sentenceTruth(SENT,vFalse))),iUniversalVocabularyMt,vStrDef).
tiny_kb(argAndRestQuotedIsa(or,1,ftSentenceAssertible),iLogicalTruthMt,vStrMon).
tiny_kb(argAndRestQuotedIsa(and,1,ftSentenceAssertible),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(rtVariableArityRelation,rtFixedArityRelation),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(rtSententialRelation,tPred),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tRelation,vtTruthValue),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tRelation,ftNonNegativeInteger),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tRelation,tMicrotheory),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tMicrotheory,vtTruthValue),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(rtLogicalConnective,rtQuantifier),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tFunction,rtTruthFunction),iLogicalTruthMt,vStrMon).
tiny_kb(disjointWith(tCol,tIndividual),iLogicalTruthMt,vStrMon).
tiny_kb(implies(disjointWith(X,Y),disjointWith(Y,X)),iLogicalTruthMt,vStrMon).
tiny_kb(implies(denotes(xQuoteFn(xEscapeQuoteFn(X)),_ANYTHING),denotes(xQuoteFn(xEscapeQuoteFn(X)),X)),iLogicalTruthMt,vStrMon).
tiny_kb(implies(and(isa(INS,SPEC),genls(SPEC,GENL)),isa(INS,GENL)),iLogicalTruthMt,vStrMon).
tiny_kb(implies(and(genls(X,Y),genls(Y,Z)),genls(X,Z)),iLogicalTruthMt,vStrMon).
tiny_kb(implies(and(genlMt(X,Y),genlMt(Y,Z)),genlMt(X,Z)),iLogicalTruthMt,vStrMon).
tiny_kb(implies(and(equals(X,Y),equals(Y,Z)),equals(X,Z)),iLogicalTruthMt,vStrMon).
tiny_kb(argQuotedIsa(exists,2,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(exists,1,ftVar),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(not,1,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(ist,2,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(implies,2,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(implies,1,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(all,2,ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(argQuotedIsa(all,1,ftVar),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(resultIsa,2,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(ist,1,tMicrotheory),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(isa,2,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(isa,1,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(genls,2,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(genls,1,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(genlMt,2,tMicrotheory),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(genlMt,1,tMicrotheory),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(equals,2,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(equals,1,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(disjointWith,2,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(disjointWith,1,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(arity,2,ftNonNegativeInteger),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(arity,1,rtFixedArityRelation),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argIsa,3,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argIsa,2,ftPositiveInteger),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argIsa,1,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argAndRestIsa,3,tCol),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argAndRestIsa,2,ftPositiveInteger),iLogicalTruthMt,vStrDef).
tiny_kb(argIsa(argAndRestIsa,1,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(rtQuantifier(exists),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(resultIsa),iLogicalTruthMt,vStrDef).
tiny_kb(rtVariableArityRelation(or),iLogicalTruthMt,vStrDef).
tiny_kb(rtLogicalConnective(or),iLogicalTruthMt,vStrDef).
tiny_kb(rtLogicalConnective(not),iLogicalTruthMt,vStrDef).
tiny_kb(rtFixedArityRelation(not),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(ist),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(isa),iLogicalTruthMt,vStrDef).
tiny_kb(rtLogicalConnective(implies),iLogicalTruthMt,vStrDef).
tiny_kb(rtFixedArityRelation(implies),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(genls),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(genlMt),iLogicalTruthMt,vStrDef).
tiny_kb(rtQuantifier(all),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(equals),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(disjointWith),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(denotes),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(arity),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(argIsa),iLogicalTruthMt,vStrDef).
tiny_kb(tPred(argAndRestIsa),iLogicalTruthMt,vStrDef).
tiny_kb(rtVariableArityRelation(and),iLogicalTruthMt,vStrDef).
tiny_kb(rtLogicalConnective(and),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtVariableArityRelation),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(vtTruthValue),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtTruthFunction),iLogicalTruthMt,vStrDef).
tiny_kb(vtTruthValue(vTrue),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tThing),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtSententialRelation),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(tFunction(xQuasiQuoteFn),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtQuantifier),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tPred),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(ftPositiveInteger),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(ftNonNegativeInteger),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tMicrotheory),iLogicalTruthMt,vStrDef).
tiny_kb(tMicrotheory(iLogicalTruthMt),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtLogicalConnective),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tIndividual),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tFunction),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(rtFixedArityRelation),iLogicalTruthMt,vStrDef).
tiny_kb(vtTruthValue(vFalse),iLogicalTruthMt,vStrDef).
tiny_kb(tFunction(uExpandSubLFn),iLogicalTruthMt,vStrDef).
tiny_kb(rtFixedArityRelation(uExpandSubLFn),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(ftVar),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(ftSentenceAssertible),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(ftCycLExpression),iLogicalTruthMt,vStrDef).
tiny_kb(tCol(tCol),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtVariableArityRelation,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtTruthFunction,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtSententialRelation,rtTruthFunction),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtQuantifier,rtSententialRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(tPred,rtTruthFunction),iLogicalTruthMt,vStrDef).
tiny_kb(genls(ftPositiveInteger,ftNonNegativeInteger),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtLogicalConnective,rtSententialRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(tIndividual,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(genls(tFunction,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(rtFixedArityRelation,tRelation),iLogicalTruthMt,vStrDef).
tiny_kb(genls(ftCycLExpression,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(genls(tCol,tThing),iLogicalTruthMt,vStrDef).
tiny_kb(arity(exists,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(resultIsa,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(not,1),iLogicalTruthMt,vStrDef).
tiny_kb(arity(ist,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(isa,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(implies,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(genls,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(genlMt,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(all,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(equals,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(disjointWith,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(denotes,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(arity,2),iLogicalTruthMt,vStrDef).
tiny_kb(arity(argIsa,3),iLogicalTruthMt,vStrDef).
tiny_kb(arity(argAndRestIsa,3),iLogicalTruthMt,vStrDef).
tiny_kb(genlMt(X,X),iLogicalTruthMt,vStrDef).
tiny_kb(equals(X,X),iLogicalTruthMt,vStrDef).
tiny_kb(quotedIsa(xQuoteFn,ftCycLExpression),iLogicalTruthMt,vStrDef).
tiny_kb(quotedIsa(xEscapeQuoteFn,ftCycLExpression),iLogicalTruthMt,vStrDef).
tiny_kb(relationAllInstance(arity,rtBinaryRelation,2),iCoreCycLMt,vStrMon).
tiny_kb(implies(rtUnaryRelation(REL),arity(REL,1)),iCoreCycLMt,vStrMon).
tiny_kb(implies(rtTernaryRelation(REL),arity(REL,3)),iCoreCycLMt,vStrMon).
tiny_kb(implies(rtQuintaryRelation(REL),arity(REL,5)),iCoreCycLMt,vStrMon).
tiny_kb(implies(rtQuaternaryRelation(REL),arity(REL,4)),iCoreCycLMt,vStrMon).
tiny_kb(implies(rtBinaryRelation(REL),arity(REL,2)),iCoreCycLMt,vStrMon).
tiny_kb(implies(and(natFunction(NAT,FUNC),resultIsaArg(FUNC,N),natArgument(NAT,N,COL)),isa(NAT,COL)),iCoreCycLMt,vStrMon).
tiny_kb(implies(and(natFunction(NAT,FUNC),resultGenlArg(FUNC,N),natArgument(NAT,N,COL)),genls(NAT,COL)),iCoreCycLMt,vStrMon).
tiny_kb(genlsSpecdenotesgenlinstances(rtDocumentationPredicate,tPred),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg6SometimesIsa,6),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg6QuotedIsa,6),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg5SometimesIsa,5),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg5QuotedIsa,5),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg4SometimesIsa,4),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg4QuotedIsa,4),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg3SometimesIsa,3),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg3QuotedIsa,3),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg2SometimesIsa,2),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg2QuotedIsa,2),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg1SometimesIsa,1),iCoreCycLMt,vStrMon).
tiny_kb(constrainsArg(arg1QuotedIsa,1),iCoreCycLMt,vStrMon).
tiny_kb(comment(nonAbducibleWithValueInArg,"A ternary predicate that is an instance of AbductionConstraintConstant (q.v.) and that can apply to a predicate and a specified value for a specified argument-place. \n
\n(nonAbducibleWithValueInArg PRED VALUE N) means that, if asked a query of the form (PRED ... VALUE ...), where VALUE appears in the Nth argument-position and all of the other positions (>= 1) are filled with variables, the Inference Engine cannot use abduction to hypothesize that any non-abduced terms are legitimate bindings for those variables.\n
\nFor example, (nonAbducibleWithValueInArg hasMembers InternationalMonetaryFund 1) holds, so Cyc cannot use abduction to hypothesize that Sealand is a member of the IMF.  (Note that this does not mean that Cyc cannot prove that some abduced term is a member of the IMF.)"),iCoreCycLMt,vStrMon).
tiny_kb(comment(completelyEnumerableCollection,"A unary InferenceCompletenessPredicate that is a specialization of completelyDecidableCollection (qq.v.).  (completelyEnumerableCollection COL) means that the CycInferenceEngine can generate a list of all of (and only) the instances of COL.  More precisely: given a query of the form (isa VAR COL), the Inference Engine can (without using transformations) return a list of terms -- bindings for the variable VAR -- such that every instance (and no non-instance) of the collection COL is denoted by some binding on the list.\n
\nFor example, SkolemFunction is a completely enumerable collection.  (But note that SkolemFunction does not satisfy the more specialized completelyAssertedCollection (q.v.), as most of its instances are only asserted to be instances of one of its specializations, such as FixedAritySkolemFunction.)\n
\nSee also completeExtentEnumerable, which applies to Predicates."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completelyDecidableCollection,"A unary InferenceCompletenessPredicate (q.v.) that applies to collections.  (completelyDecidableCollection COL) means that the CycInferenceEngine can determine if any given thing is an instance of COL.  More precisely: for any given instance INST whatsoever (and for no non-instances) of COL, there is a CycL term INST-TERM that denotes INST such that (without using transformations) the Inference Engine, given a query of the form (isa INST-TERM COL), will return the answer True.\n
\nFor example, the collection Integer is completely decidable. Given any integer INT, the Cyc query (isa INT Integer) -- wherein INT is given its standard base-10 arabic numeral representation -- will come back True.\n
\nIf COL is completely decidable and Cyc fails to return True for some query (isa TERM COL), that fact consitutes a strong argument for the truth of its negation (not (isa TERM COL)).  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and the term TERM could conceivably denote something that Cyc can prove to be an instance of COL only under some other CycL name it has.  For suppose Pace's favorite number happens to be 3, but nobody has told that to Cyc.  Cyc can prove the sentence (isa 3 Integer); but it might nevertheless fail to prove the equally true sentence\n
\n  (isa (FavoriteNumberOfFn Pace) Integer) .\n
\nSee also the more specific predicates completelyEnumerableCollection and completelyAssertedCollection.  And see completeExtentDecidable, which applies to Predicates."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentEnumerableViaBackchain,"A unary InferenceCompletenessPredicate and a specialization of  minimizeExtent (qq.v.) that applies to predicates whose entire extents can be enumerated by reference to the transformation rules currently asserted on it.  For example, surgicalIncisionEmployed is completeExtentEnumerableViaBackchain in the context of certain medical domain microtheories because the pair of rules on it are sufficient to completely generate its entire extent within those microtheories."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentEnumerableForValueInArg,"A ternary InferenceCompletenessPredicate and a specialization of completeExtentDecidableForValueInArg (q.v.) that can apply to a predicate and a specified value for a specified argument-place.  (completeExtentEnumerableForValueInArg PRED VALUE N) means that the CycInferenceEngine can enumerate every sequence in the extent of PRED whose Nth item is VALUE.  In practical terms this means that, if asked a query of the form (PRED ... VALUE ...), where VALUE appears in the Nth argument-position and all of the other positions (>= 1) are filled with variables, the Inference Engine can return an extensionally complete list of binding-sequences for those variables.  That is, for every sequence SEQ in PRED's extension whose Nth member is VALUE (and for nothing else), the returned list contains a sequence of bindings (i.e. CycL terms) whose members denote, pointwise, the members of SEQ excepting VALUE.\n
\nFor example, (completeExtentEnumerableForValueInArg hasMembers InternationalMonetaryFund 1) holds, as Cyc can enumerate all the members of the International Monetary Fund.\n
\nIf PRED's extent is completely enumerable for VALUE in the Nth argument and a given sequence of bindings <TERM1, ..., TERM(N-1), TERM(N+1), ...> (whose length matches the arity of PRED, if fixed) is not returned for the above query, that fact consitutes a strong argument for the truth of the negation (not (PRED TERM1 ... TERM(N-1) VALUE TERM(N+1) ...)).  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and a term TERMi could conceivably denote something that Cyc can prove a member of a sequence in the extent of PRED only under some other CycL name it has.  For suppose Pace resides in Texas, but nobody has told that to Cyc.  Cyc can return the binding 'Texas-State' for the query '(cityInState CityOfDallasTX ?X)'; but it might nevertheless fail to return the equally correct binding '(StateOfResidenceFn Pace)'.\n
\nSee also the specialization completeExtentAssertedForValueInArg and see completeExtentEnumerableForArg."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentEnumerableForArg,"A binary InferenceCompletenessPredicate (q.v.) that can apply to a predicate and a specified argument-place.  (completeExtentEnumerableForArg PRED N) means that, for any given thing ARGN, the CycInferenceEngine can enumerate every sequence in the extent of PRED whose Nth item is ARGN (see relationExtension and relationHoldsAmong).  In practical terms this means that, if asked a query of the form (PRED ... ARGN ...), where all of PRED's argument-places save the Nth are filled with variables, the Inference Engine can return an extensionally complete list of binding-sequences for the other (i.e. non-Nth) arguments.  That is, for every sequence SEQ in PRED's extension whose Nth member is ARGN (and for nothing else), the returned list contains a sequence of bindings (i.e. CycL terms) whose members denote, pointwise, the members of SEQ excepting ARGN.\n
\nFor example, (completeExtentEnumerableForArg cityInState 1) holds: given any city, Cyc can return a list of all the states (i.e. the one state, if any) in which it is located.\n
\nIf PRED's extent is completely enumerable for the Nth argument and a given sequence of bindings  (whose length matches the arity of PRED, if fixed) is not returned for the above query, that fact consitutes a strong argument for the truth of the negation (not (PRED TERM1 ... TERM(N-1) ARGN TERM(N+1) ...)).  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and a term TERMi could conceivably denote something that Cyc can prove a member of a sequence in the extent of PRED only under some _other_ CycL name it has.  For suppose Pace resides in Texas, but nobody has told that to Cyc.  Cyc can return the binding 'Texas-State' for the query '(cityInState CityOfDallasTX ?X)'; but it might nevertheless fail to return the equally correct binding '(StateOfResidenceFn Pace)'.\n
\nSee also completeExtentEnumerable and completeExtentEnumerableForValueInArg)."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentEnumerableForArg,"(completeExtentEnumerableForArg PRED ARGNUM) means that when the CycInferenceEngine   is asked a query of the form (PRED ... ARG ...) where ARG is any closed term in the                  ARGNUMth position, it can completely enumerate all possible bindings for the other argument          positions.                                                                                           This means that for any arguments (PRED ... NOT-ARGi ... ARG ... NOT-ARGj) for which the             NOT-ARGs are not a member of the enumerated bindings,                                                (not (PRED ... NOT-ARGi ... ARG ... NOT-ARGj)) is true."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentEnumerable,"A unary InferenceCompletenessPredicate and a specialization of completeExtentDecidable and minimizeExtent (qq.v.) that applies to predicates whose entire extents can be enumerated by the CycInferenceEngine.  (completeExtentEnumerable PRED) means that the Inference Engine can, without using transformations, generate a list of all of (and only) the sequences of things among which PRED holds (see relationExtension and relationHoldsAmong).\n
\nFor example, (completeExtentEnumerable call_u_no_bc) holds, as the Inference Engine could, if asked, list all of the assertions in the Knowledge Base.  Conversely, although the Inference engine could correctly determine if any given CycL sentence is in the extent of knownSentence (i.e completeExtentDecidable holds of knownSentence), it could not generate a list of all CycL sentences in the extent of knownSentence.\n
\nThe practical import of completeExtentEnumerable can be stated more precisely as follows.  Let's say that an N-length sequence of terms \"pointwise-denotes\" an N-length sequence of things just in case each term in the former denotes the corresponding item in the latter.  Suppose (completeExtentEnumerable PRED) holds.  If PRED is a FixedArityRelation of arity N and VAR1...VARN are N distinct CycLVariables, then, given a query of the form (PRED VAR1 ... VARN), the Inference Engine can, without the use of Transformation Modules, return a list of N-length sequences of terms -- each sequence consisting of bindings for the respective variables VAR1-VARN -- such that every sequence in PRED's extent (and nothing else) is pointwise-denoted by some term-sequence on the list.   If PRED is a VariableArityRelation, it is the same, except the given query should then have the form (PRED . VARS), and there might be no constant length N shared by all of the term-sequences in the returned list.\n
\nIf PRED's extent is completely enumerable and a given term-sequence  is not in the list returned for the above query, that fact consitutes a strong argument for the truth of the negation (not (PRED TERM-1 ... TERM-N)), assuming that it's semantically well-formed.  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and some term TERM-I could conceivably denote something that Cyc can prove to be a member of something in the extent of PRED only under some other CycL name it has.  For suppose Pace was also denoted by the (imaginary) CycL term ErasmusCAnderson, but Cyc did not know that Pace and Erasmus C. Anderson are the same person.  Cyc will return the term-sequence <Pace, GeneralCycKE> for the query (cyclistPrimaryProject ?X ?Y); but it might nevertheless fail to return the sequence <ErasmusCAnderson, GeneralCycKE>, even though the sentence\n
\n  (cyclistPrimaryProject ErasmusCAnderson GeneralCycKE)\n
\nwas in fact true."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentDecidableForValueInArg,"(completeExtentDecidableForValueInArg PRED VALUE ARGNUM) means that when the            CycInferenceEngine                                                                                 is asked a closed query of the form (PRED ... VALUE ...) where VALUE appears in the                  ARGNUMth position, either it can prove (PRED ... VALUE ...) without transformation,                  or (not (PRED ... VALUE ...)) is true."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentDecidable,"A unary InferenceCompletenessPredicate (q.v.) that applies to predicates.  (completeExtentDecidable PRED) means that the CycInferenceEngine can determine if any given sequence of things is in the extent of PRED (see relationExtension and relationHoldsAmong).  More precisely: for any given n-length sequence SEQ among which PRED holds (and for nothing else), there are CycL terms TERM1, ..., TERMN that denote the respective items in SEQ such that (without using transformations) the Inference Engine, given a query of the form (PRED TERM1 ... TERMN), will return the answer True.\n
\nFor example, (completeExtentDecidable integerBetween) holds, as the Inference engine can correctly determine if any given triple of integers is such that the second member is numerically between the first and third.  Conversely, the extent of likesAsFriend is not decidable, as many of the friendships in the world are beyond Cyc's ken.\n
\nIf PRED's extent is completely decidable and there are CycL terms TERM1, ..., TERMN such that the sentence (PRED TERM1 ... TERMN) is semantically well-formed but not provable by the Inference Engine, that fact consitutes a strong argument for the truth of its negation (not (PRED TERM1 ... TERM1)).  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and some TERMI could conceivably denote something that Cyc can prove to be a member of a sequence in the extent of PRED only under some other CycL name it has.  For suppose Pace's favorite number happens to be 3, but nobody has told that to Cyc.  Cyc can prove the sentence (integerBetween 1 2 3); but it might nevertheless fail to prove the equally true sentence\n
\n  (integerBetween 1 2 (FavoriteNumberOfFn Pace)) .\n
\nSee also the more specific predicates completeExtentEnumerable and completeExtentAsserted.  And see completelyDecidableCollection."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentAssertedForValueInArg,"A ternary InferenceCompletenessPredicate and a specialization of completeExtentEnumerableForValueInArg (q.v.) that can apply to a predicate and a specified value for a specified argument-place.  (completeExtentAssertedForValueInArg PRED VALUE N) means that for every sequence of arguments that PRED holds of and whose Nth member is VALUE, there is an explicit assertion to that effect in the Cyc Knowledge Base.  Thus, if asked a query of the form (PRED ... VALUE ...), where VALUE appears in the Nth argument-position and all of the other positions (>= 1) are filled with variables, the Inference Engine -- simply via lookup of assertions in the KB -- can return an extensionally complete list of binding-sequences for those variables.  That is, for every sequence SEQ in PRED's extension whose Nth member is VALUE (and for nothing else), the returned list contains a sequence of bindings (i.e. CycL terms) whose members denote, pointwise, the members of SEQ excepting VALUE.\n
\nFor example, (completeExtentAssertedForValueInArg hasMembers InternationalMonetaryFund 1) holds, as all the members of the International Monetary Fund are asserted to be such in the KB.\n
\nIf PRED's extent is completely asserted for VALUE in the Nth argument and a given sequence of bindings  (whose length matches the arity of PRED, if fixed) is not returned for the above query, that fact consitutes a strong argument for the truth of the negation (not (PRED TERM1 ... TERM(N-1) VALUE TERM(N+1) ...)).  But note that it is not a conclusive argument: the normally-reliable \"unique name assumption\" might fail here, and a term TERMi could conceivably denote something that Cyc can prove a member of something in the extent of PRED only under some _other_ CycL name it has.  For suppose Pace resides in Texas, but nobody has told that to Cyc.  The KB contains the assertion '(cityInState CityOfDallasTX Texas-State)'; but it might nevertheless fail to contain the equally true sentence '(cityInState CityOfDallasTX (StateOfResidenceFn Pace))'.\n
\nSee also completeExtentAsserted."),iCoreCycLMt,vStrMon).
tiny_kb(comment(completeExtentAsserted,"A unary InferenceCompletenessPredicate and a specialization of completeExtentEnumerable (q.v.) that applies to predicates whose entire extents are explicitly asserted in the Cyc Knowledge Base.  (completeExtentAsserted PRED) means that, for every sequence N> that satisfies PRED, (PRED THING1 ... THINGN) is asserted in the Knowledge Base.  That is, for each such sequence, there are reified CycL terms PRED-NAME, TERM1, ..., TERMN -- which denote PRED, THING1, ..., THINGN, respectively -- such that the sentence (PRED-NAME TERM1 ... TERMN) built from those terms is an assertion in the KB.\n
\nIf completeExtentAsserted is true of PRED, then the CycInferenceEngine, when asked a query of the form (PRED . VARS), can return a complete set of bindings for the variables in VARS simply via a lookup of assertions in the KB.  By a \"complete set of bindings\" is meant a set of sequences of terms such that, for each sequence N> in the extent of PRED, there is a corresponding sequence of terms N> returned wherein each TERMI denotes THINGI (for 1 <= I <= N).\n
\nFor example, (completeExtentAsserted hourOfDayIndex-24Hour) holds.  Thus, the sentence (hourOfDayIndex-24Hour TimeOfDay-1AM 1) is one of twenty-four similar ground-atomic sentences asserted in the KB.  Conversely, (completeExtentAsserted argN) does not hold.  Thus, while the Inference Engine could generate the set of all true argN based ground-atomic sentences (i.e. completeExtentEnumerable holds of argN), the members of this set are not all asserted in the KB.\n
\nSee also completelyAssertedCollection, which applies to collections rather than predicates."),iCoreCycLMt,vStrMon).
tiny_kb(comment(collectionCompletelyEnumerableViaBackchain,"A unary InferenceCompletenessPredicate.  (collectionCompletelyEnumerableViaBackchain COL) means that the CycInferenceEngine can generate a list of all of (and only) the instances of COL by appeal to isa consequent rules.  For example, in certain medical domain microtheories, MazeProcedure-SurgicalProcedure is collectionCompletelyEnumerableViaBackchain because backchaining on its single rule is sufficient to generate all the relevant instances in those microtheories."),iCoreCycLMt,vStrMon).
tiny_kb(implies(and(natFunction(NAT,FUNCTION),resultIsa(FUNCTION,COL)),isa(NAT,COL)),iCoreCycLMt,vStrMon).
tiny_kb(implies(and(natFunction(NAT,FUNCTION),resultGenl(FUNCTION,COL)),genls(NAT,COL)),iCoreCycLMt,vStrMon).
tiny_kb(implies(and(rtArgIsaBinaryPredicate(ARG_ISA),constrainsArg(ARG_ISA,NUM)),trueRule('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),and(implies(t(ARG_ISA,RELN,COL),argIsa(RELN,NUM,COL)),implies(argIsa(RELN,NUM,COL),t(ARG_ISA,RELN,COL))))),iCoreCycLMt,vStrMon).
tiny_kb(tPred(means),iCoreCycLMt,vStrDef).
tiny_kb(tPred(expresses),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ttUnitOfMeasure),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtUnaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtUnaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtUnaryFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtTransitiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(rtReifiableFunction(tColOfTheCollectionOfFn),iCoreCycLMt,vStrDef).
tiny_kb(rtCollectionDenotingFunction(tColOfTheCollectionOfFn),iCoreCycLMt,vStrDef).
tiny_kb(rtBinaryFunction(tColOfTheCollectionOfFn),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtTernaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtTernaryFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtSymmetricBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tSet),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ttSiblingDisjointAttributeType),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ttSetOrCollection),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tSetMathematical),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vSeptember),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtScopingRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vtScalarPointValue),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vtScalarInterval),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtReflexiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuintaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuintaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuintaryFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuaternaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuaternaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtQuaternaryFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(mtProblemSolvingCntxt),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtPartiallyCommutativeRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vOctober),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vNovember),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonNegativeScalarInterval),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tMultigraph),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vtMonthOfYearType),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtMicrotheoryDesignatingRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vMay),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vMarch),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftList),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tKnowledgeBase),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vJune),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vJuly),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vJanuary),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtIrreflexiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtInterArgIsaPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtInterArgFormatPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftInt),iCoreCycLMt,vStrDef).
tiny_kb(tCol(mtHypotheticalContext),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tHumanCyclist),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vtFormat),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vFebruary),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtExistentialQuantifier),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtExceptionPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtEvaluatableRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtEvaluatableFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtDocumentationPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftDocumentationConstant),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtDistributingMetaKnowledgePredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(tDirectedMultigraph),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vDecember),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftVar),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftTruthValueSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentenceAssertible),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentenceAssertible),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentenceAskable),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftRuleAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftRepresentedTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftRepresentedAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftReifiedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftReifiableDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftPropositionalSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftCycLOpenExpression),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicTermAssertible),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicTermAskable),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftNonAtomicReifiedTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(mobCyclist),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftGenericRelationFormula),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftGAFAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftExpressionAssertible),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftExpressionAskable),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftDeducedAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftConstant),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftClosedSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftClosedNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftClosedFormula),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftCycLClosedExpression),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftClosedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftClosedAtomicSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAtomicSentence),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAtomicAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(ftAssertedAssertion),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtCommutativeRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtCollectionDenotingFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtBookkeepingPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtBinaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtBinaryFunction),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vAugust),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtAsymmetricBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtAssociativeRelation),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgTypeTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgTypePredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgTypeBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgQuotedIsaTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgIsaTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgIsaBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgGenlTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgGenlQuantityTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgGenlQuantityBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgGenlBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtArgConstraintPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(vApril),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtAntiTransitiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(tCol(rtAntiSymmetricBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtUnaryRelation,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtUnaryPredicate,rtUnaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtUnaryPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtUnaryFunction,rtUnaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtUnaryFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTransitiveBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTernaryRelation,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTernaryPredicate,rtTernaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTernaryPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTernaryFunction,rtTernaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtTernaryFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtSymmetricBinaryPredicate,rtCommutativeRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtSymmetricBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(ttSetOrCollection,tThing),iCoreCycLMt,vStrDef).
tiny_kb(genls(tSetMathematical,ttSetOrCollection),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtScopingRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(vtScalarPointValue,vtScalarInterval),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtReflexiveBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftRealNumber,vtScalarPointValue),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuintaryRelation,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuintaryPredicate,rtQuintaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuintaryPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuintaryFunction,rtQuintaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuintaryFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuaternaryRelation,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuaternaryPredicate,rtQuaternaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuaternaryPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuaternaryFunction,rtQuaternaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuaternaryFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtQuantifier,rtScopingRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(mtProblemSolvingCntxt,tMicrotheory),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftPositiveInteger,ftInt),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtPartiallyCommutativeRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonNegativeScalarInterval,vtScalarInterval),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonNegativeInteger,ftInt),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtMicrotheoryDesignatingRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtIrreflexiveBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtInterArgFormatPredicate,rtTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(mtHypotheticalContext,tMicrotheory),iCoreCycLMt,vStrDef).
tiny_kb(genls(tHumanCyclist,mobCyclist),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtExistentialQuantifier,rtQuantifier),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtEvaluatableRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtEvaluatableFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtEvaluatableFunction,rtEvaluatableRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDocumentationConstant,ftConstant),iCoreCycLMt,vStrDef).
tiny_kb(genls(tDirectedMultigraph,tMultigraph),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftVar,ftRepresentedAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftVar,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftVar,ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftTruthValueSentence,ftClosedSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftExpression,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentenceAssertible,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentenceAssertible,ftSentenceAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentenceAssertible,ftExpressionAssertible),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentenceAskable,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentenceAskable,ftExpressionAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftRuleAssertion,ftAssertion),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftRepresentedTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftRepresentedAtomicTerm,ftRepresentedTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftRepresentedAtomicTerm,ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftReifiedDenotationalTerm,ftReifiableDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftReifiableDenotationalTerm,ftClosedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftPropositionalSentence,ftSentenceAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftPropositionalSentence,ftClosedSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftCycLOpenExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftCycLOpenExpression,ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftCycLOpenExpression,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDenotationalTerm,ftCycLOpenExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDenotationalTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTermAssertible,ftNonAtomicTermAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTermAssertible,ftExpressionAssertible),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTermAskable,ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTermAskable,ftExpressionAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftRepresentedTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicReifiedTerm,ftReifiedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftNonAtomicReifiedTerm,ftClosedNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftGenericRelationFormula,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftGAFAssertion,ftClosedAtomicSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftGAFAssertion,ftAtomicAssertion),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftSentence,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftExpressionAssertible,ftExpressionAskable),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftExpressionAskable,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftCycLExpression,ftSubLSExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDenotationalTerm,ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDenotationalTerm,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftDeducedAssertion,ftAssertion),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftConstant,ftRepresentedAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftConstant,ftReifiedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftConstant,ftReifiableDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftConstant,ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedSentence,ftSentenceAssertible),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedNonAtomicTerm,ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedNonAtomicTerm,ftNonAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedNonAtomicTerm,ftClosedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedFormula,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedFormula,ftCycLClosedExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftCycLClosedExpression,ftExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftCycLClosedExpression,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedDenotationalTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedDenotationalTerm,ftCycLClosedExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicTerm,ftClosedDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicTerm,ftAtomicTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftClosedAtomicSentence,ftAtomicSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicTerm,ftCycLExpression),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicTerm,ftDenotationalTerm),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicSentence,ftSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicAssertion,ftAtomicSentence),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAtomicAssertion,ftAssertion),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAssertion,ftSentenceAssertible),iCoreCycLMt,vStrDef).
tiny_kb(genls(ftAssertedAssertion,ftAssertion),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtCommutativeRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtCollectionDenotingFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(tCol,ttSetOrCollection),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBookkeepingPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryRelation,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryPredicate,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryPredicate,rtFixedArityRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryPredicate,rtBinaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryFunction,tFunction),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtBinaryFunction,rtBinaryRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtAsymmetricBinaryPredicate,rtIrreflexiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtAsymmetricBinaryPredicate,rtAntiSymmetricBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtAssociativeRelation,tRelation),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgTypeTernaryPredicate,rtTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgTypeTernaryPredicate,rtArgTypePredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgTypePredicate,rtArgConstraintPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgTypeBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgTypeBinaryPredicate,rtArgTypePredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgQuotedIsaTernaryPredicate,rtArgTypeTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgQuotedIsaBinaryPredicate,rtArgTypeBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgIsaTernaryPredicate,rtArgTypeTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgIsaBinaryPredicate,rtArgTypeBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgGenlTernaryPredicate,rtArgTypeTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgGenlQuantityTernaryPredicate,rtArgTypeTernaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgGenlQuantityBinaryPredicate,rtArgTypeBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtArgGenlBinaryPredicate,rtArgTypeBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtAntiTransitiveBinaryPredicate,rtIrreflexiveBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(genls(rtAntiSymmetricBinaryPredicate,rtBinaryPredicate),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentDecidableForValueInArg,3,ftNonNegativeInteger),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentAssertedForValueInArg,3,ftNonNegativeInteger),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentEnumerableForArg,2,ftNonNegativeInteger),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentDecidableForValueInArg,2,tThing),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentAssertedForValueInArg,2,tThing),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completelyDecidableCollection,1,tCol),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentEnumerableForArg,1,tPred),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentDecidableForValueInArg,1,tPred),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentDecidable,1,tPred),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentAssertedForValueInArg,1,tPred),iCoreCycLMt,vStrDef).
tiny_kb(argIsa(completeExtentAsserted,1,tPred),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completelyEnumerableCollection,completelyDecidableCollection),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentEnumerableViaBackchain,minimizeExtent),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentEnumerableForValueInArg,nonAbducibleWithValueInArg),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentEnumerableForValueInArg,completeExtentDecidableForValueInArg),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentEnumerable,minimizeExtent),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentEnumerable,completeExtentDecidable),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentAssertedForValueInArg,completeExtentEnumerableForValueInArg),iCoreCycLMt,vStrDef).
tiny_kb(genlPreds(completeExtentAsserted,completeExtentEnumerable),iCoreCycLMt,vStrDef).
tiny_kb(implies(completelyEnumerableCollection(COL),completeExtentEnumerableForValueInArg(isa,COL,2)),iCoreCycLMt,vStrDef).
tiny_kb(implies(completelyDecidableCollection(COL),completeExtentDecidableForValueInArg(isa,COL,2)),iCoreCycLMt,vStrDef).
tiny_kb(implies(completeExtentEnumerableForValueInArg(isa,COL,2),completelyEnumerableCollection(COL)),iCoreCycLMt,vStrDef).
tiny_kb(implies(completeExtentDecidableForValueInArg(isa,COL,2),completelyDecidableCollection(COL)),iCoreCycLMt,vStrDef).
tiny_kb(implies(and(natFunction(NAT,FUNC),isa(TERM,INDEP_COL),natArgument(NAT,N,TERM),interArgResultIsa(FUNC,N,INDEP_COL,DEP_COL)),isa(NAT,DEP_COL)),iCoreCycLMt,vStrDef).
tiny_kb(quotedIsa(vTrue,ftTruthValueSentence),iCoreCycLMt,vStrDef).
tiny_kb(quotedIsa(vFalse,ftTruthValueSentence),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(argsIsa,0),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(argsGenl,0),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg6Isa,6),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg6Genl,6),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg5Isa,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg5Genl,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg5Format,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg4Isa,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg4Genl,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg4Format,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg3Isa,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg3Genl,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg3Format,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg2Isa,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg2Genl,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg2Format,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg1Isa,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg1Genl,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(arg1Format,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa5_4,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa5_3,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa5_2,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa5_1,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa4_5,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa4_3,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa4_2,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa4_1,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa3_5,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa3_4,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa3_2,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa3_1,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa2_5,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa2_4,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa2_3,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa2_1,1),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa1_5,5),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa1_4,4),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa1_3,3),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgIsa1_2,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgGenl1_2,2),iCoreCycLMt,vStrDef).
tiny_kb(constrainsArg(interArgFormat1_2,2),iCoreCycLMt,vStrDef).
tiny_kb(implies(and(natFunction(NAT,FUNCTION),resultQuotedIsa(FUNCTION,COL)),quotedIsa(NAT,COL)),iCoreCycLMt,vStrDef).
tiny_kb(implies(different(ftNonAtomicTerm,COL),meetsPragmaticRequirement(vTheListFn(NAT,FUNCTION,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[natFunction,NAT,FUNCTION],[resultQuotedIsa,FUNCTION,COL]],[[quotedIsa,NAT,COL]]],iCoreCycLMt,s("?NAT","?FUNCTION","?COL"),[implies,[and,[natFunction,NAT,FUNCTION],[resultQuotedIsa,FUNCTION,COL]],[quotedIsa,NAT,COL]]))),iCoreCycLMt,vStrDef).
tiny_kb(interArgResultIsa(vRoundUpFn,1,vtScalarPointValue,vtScalarPointValue),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vRoundUpFn,1,ftRealNumber,ftInt),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vRoundDownFn,1,vtScalarPointValue,vtScalarPointValue),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vRoundDownFn,1,ftRealNumber,ftInt),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vRoundClosestFn,1,vtScalarPointValue,vtScalarPointValue),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vRoundClosestFn,1,ftRealNumber,ftInt),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vModuloFn,1,ftInt,ftNonNegativeInteger),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(vIntervalMinFn,1,ftNonNegativeScalarInterval,ftNonNegativeScalarInterval),iBaseKB,vStrMon).
tiny_kb(argIsa(resultIsa,1,tRelation),iBaseKB,vStrMon).
tiny_kb(argIsa(resultGenl,1,tRelation),iBaseKB,vStrMon).
tiny_kb(unitMultiplicationFactor(UNIT,UNIT,1),iBaseKB,vStrMon).
tiny_kb(multiplicationUnits(vUnityFn,UNIT,UNIT),iBaseKB,vStrMon).
tiny_kb(commutativeInArgs(multiplicationUnits,1,2),iBaseKB,vStrMon).
tiny_kb(commutativeInArgs(interArgDifferent,2,3),iBaseKB,vStrMon).
tiny_kb(relationAllExists(constantID,ftConstant,ftNonNegativeInteger),iBaseKB,vStrMon).
tiny_kb(relationAllExists(natFunction,ftNonAtomicTerm,rtReifiableFunction),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(arity,rtQuaternaryRelation,4),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(arity,rtQuintaryRelation,5),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(arity,rtTernaryRelation,3),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(arity,rtUnaryRelation,1),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(genlPreds,rtIrreflexiveBinaryPredicate,different),iBaseKB,vStrMon).
tiny_kb(relationAllInstance(genls,tCol,tThing),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg1Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg1Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg2Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg2Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg3Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg3Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg4Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg4Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg5Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg5Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg6Genl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(arg6Isa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(argAndRestIsa,genls,3),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(argIsa,genls,3),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(argsGenl,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(argsIsa,genls,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(holdsIn,sentenceImplies,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArg(subsetOf,subsetOf,2),iBaseKB,vStrMon).
tiny_kb(transitiveViaArgInverse(subsetOf,subsetOf,1),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(trueSubL,uSubLQuoteFn('CYC-TRUE-SUBL')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(substring,uSubLQuoteFn('CYC-SUBSTRING-PREDICATE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(quantitySubsumes,uSubLQuoteFn('CYC-QUANTITY-SUBSUMES')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(quantityIntersects,uSubLQuoteFn('CYC-QUANTITY-INTERSECTS')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(numericallyEquals,uSubLQuoteFn('CYC-NUMERICALLY-EQUAL')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(greaterThanOrEqualTo,uSubLQuoteFn('CYC-GREATER-THAN-OR-EQUAL-TO')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(greaterThan,uSubLQuoteFn('CYC-GREATER-THAN')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(differentSymbols,uSubLQuoteFn('CYC-DIFFERENT-SYMBOLS')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(different,uSubLQuoteFn('CYC-DIFFERENT')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vTimesFn,uSubLQuoteFn('CYC-TIMES')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(substringCaseinsensitive,uSubLQuoteFn('CYC-SUBSTRING-CASE-INSENSITIVE-PREDICATE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vRoundUpFn,uSubLQuoteFn('CYC-ROUND-UP')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vRoundDownFn,uSubLQuoteFn('CYC-ROUND-DOWN')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vRoundClosestFn,uSubLQuoteFn('CYC-ROUND-CLOSEST')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vQuotientFn,uSubLQuoteFn('CYC-QUOTIENT')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vQuantityConversionFn,uSubLQuoteFn('CYC-QUANTITY-CONVERSION')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vPlusFn,uSubLQuoteFn('CYC-PLUS')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vPlusAllFn,uSubLQuoteFn('CYC-PLUS-ALL')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vPercentFn,uSubLQuoteFn('CYC-PERCENT')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vMinRangeFn,uSubLQuoteFn('CYC-MIN-RANGE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vMinimumFn,uSubLQuoteFn('CYC-MINIMUM')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vMaxRangeFn,uSubLQuoteFn('CYC-MAX-RANGE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vMaximumFn,uSubLQuoteFn('CYC-MAXIMUM')),iBaseKB,vStrMon).
tiny_kb(denotes(xQuoteFn(xQuoteFn(xEscapeQuoteFn(X))),xQuoteFn(xEscapeQuoteFn(X))),iBaseKB,vStrMon).
tiny_kb(definingMt(subsetOf,iCoreCycLMt),iBaseKB,vStrMon).
tiny_kb(definingMt(skolem,iBaseKB),iBaseKB,vStrMon).
tiny_kb(definingMt(ruleAfterRemoving,iBaseKB),iBaseKB,vStrMon).
tiny_kb(definingMt(ruleAfterAdding,iBaseKB),iBaseKB,vStrMon).
tiny_kb(definingMt(oldConstantName,iBookkeepingMt),iBaseKB,vStrMon).
tiny_kb(definingMt(myCreator,iBookkeepingMt),iBaseKB,vStrMon).
tiny_kb(definingMt(myCreationTime,iBookkeepingMt),iBaseKB,vStrMon).
tiny_kb(definingMt(equals,iLogicalTruthMt),iBaseKB,vStrMon).
tiny_kb(definingMt(elementOf,iCoreCycLMt),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(iFunctionToArgFn(N,PREDICATE),uSubLQuoteFn('CYC-FUNCTION-TO-ARG')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vFormulaArityFn,uSubLQuoteFn('CYC-RELATION-EXPRESSION-ARITY')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(tSetOfFormulaArgSetFn,uSubLQuoteFn('CYC-RELATION-ARG-SET')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vFormulaArgListFn,uSubLQuoteFn('CYC-RELATION-ARGS-LIST')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(uFormulaArgFn,uSubLQuoteFn('CYC-RELATION-ARG')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(uEvaluateSubLFn,uSubLQuoteFn('CYC-EVALUATE-SUBL')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vDifferenceFn,uSubLQuoteFn('CYC-DIFFERENCE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(xDateEncodeStringFn,uSubLQuoteFn('CYC-DATE-ENCODE-STRING')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(iTimeOf_DateDecodeStringFn,uSubLQuoteFn('CYC-DATE-DECODE-STRING')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vAverageFn,uSubLQuoteFn('CYC-AVERAGE')),iBaseKB,vStrMon).
tiny_kb(evaluationDefn(vAbsoluteValueFn,uSubLQuoteFn('CYC-ABSOLUTE-VALUE')),iBaseKB,vStrMon).
tiny_kb(equiv(arity(REL,4),rtQuaternaryRelation(REL)),iBaseKB,vStrMon).
tiny_kb(equiv(arity(REL,2),rtBinaryRelation(REL)),iBaseKB,vStrMon).
tiny_kb(expansion(resultIsa,implies(equals(VALUE,'NART'([':ARG1','?ARGS'])),':ARG2'(VALUE))),iBaseKB,vStrMon).
tiny_kb(expansion(resultGenl,implies(equals(VALUE,'NART'([':ARG1','?ARGS'])),genls(VALUE,':ARG2'))),iBaseKB,vStrMon).
tiny_kb(expansion(relationInstanceAll,implies(':ARG3'(INS),':ARG1'(':ARG2',INS))),iBaseKB,vStrMon).
tiny_kb(expansion(relationExistsAll,implies(':ARG3'(TERM),':ARG1'(uRelationExistsAllFn(TERM,':ARG1',':ARG2',':ARG3'),TERM))),iBaseKB,vStrMon).
tiny_kb(expansion(relationAllInstance,implies(':ARG2'(INS),':ARG1'(INS,':ARG3'))),iBaseKB,vStrMon).
tiny_kb(expansion(relationAllExists,implies(':ARG2'(TERM),':ARG1'(TERM,uRelationAllExistsFn(TERM,':ARG1',':ARG2',':ARG3')))),iBaseKB,vStrMon).
tiny_kb(expansion(genlMt,implies(ist(':ARG2',ASSERTION),ist(':ARG1',ASSERTION))),iBaseKB,vStrMon).
tiny_kb(equals(vTheEmptyList,vTheListFn),iBaseKB,vStrMon).
tiny_kb(equals(X,X),iBaseKB,vStrMon).
tiny_kb(termOfUnit('NART'([iCollectionRuleTemplateFn,mtHypotheticalContext]),iCollectionRuleTemplateFn(mtHypotheticalContext)),iBaseKB,vStrMon).
tiny_kb(termOfUnit('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),iCollectionRuleTemplateFn(rtArgIsaPredicate)),iBaseKB,vStrMon).
tiny_kb(subsetOf(iTheEmptySet,SET),iBaseKB,vStrMon).
tiny_kb(implies(ttUnitOfMeasure(UNIT),arityMin(UNIT,1)),iBaseKB,vStrMon).
tiny_kb(implies(ttUnitOfMeasure(UNIT),arityMax(UNIT,2)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,5,IND_COL,4,DEP_COL),interArgIsa(PRED,5,IND_COL,4,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,5,IND_COL,3,DEP_COL),interArgIsa(PRED,5,IND_COL,3,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,5,IND_COL,2,DEP_COL),interArgIsa(PRED,5,IND_COL,2,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,5,IND_COL,1,DEP_COL),interArgIsa(PRED,5,IND_COL,1,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,4,IND_COL,5,DEP_COL),interArgIsa(PRED,4,IND_COL,5,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,4,IND_COL,3,DEP_COL),interArgIsa(PRED,4,IND_COL,3,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,4,IND_COL,2,DEP_COL),interArgIsa(PRED,4,IND_COL,2,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,4,IND_COL,1,DEP_COL),interArgIsa(PRED,4,IND_COL,1,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,3,IND_COL,5,DEP_COL),interArgIsa(PRED,3,IND_COL,5,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,3,IND_COL,4,DEP_COL),interArgIsa(PRED,3,IND_COL,4,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,3,IND_COL,2,DEP_COL),interArgIsa(PRED,3,IND_COL,2,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,3,IND_COL,1,DEP_COL),interArgIsa(PRED,3,IND_COL,1,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,2,IND_COL,5,DEP_COL),interArgIsa(PRED,2,IND_COL,5,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,2,IND_COL,4,DEP_COL),interArgIsa(PRED,2,IND_COL,4,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,2,IND_COL,3,DEP_COL),interArgIsa(PRED,2,IND_COL,3,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,1,IND_COL,5,DEP_COL),interArgIsa(PRED,1,IND_COL,5,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,1,IND_COL,4,DEP_COL),interArgIsa(PRED,1,IND_COL,4,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,1,IND_COL,3,DEP_COL),interArgIsa(PRED,1,IND_COL,3,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(interArgIsa(PRED,1,IND_COL,2,DEP_COL),interArgIsa(PRED,1,IND_COL,2,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(resultIsaArg(FUNC,6),argGenl(FUNC,6,COL)),resultIsa(FUNC,COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(resultIsa(FUNCTION,COLTYPE),genls(COLTYPE,tCol)),rtCollectionDenotingFunction(FUNCTION)),iBaseKB,vStrMon).
tiny_kb(implies(rtTransitiveBinaryPredicate(PRED),transitiveViaArg(PRED,PRED,2)),iBaseKB,vStrMon).
tiny_kb(implies(rtReflexiveBinaryPredicate(PRED),genlPreds(equals,PRED)),iBaseKB,vStrMon).
tiny_kb(implies(rtIrreflexiveBinaryPredicate(PRED),genlPreds(PRED,different)),iBaseKB,vStrMon).
tiny_kb(implies(rtInferenceRelatedBookkeepingPredicate(PRED),definingMt(PRED,iBaseKB)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgIsaTernaryPredicate(PRED),transitiveViaArg(PRED,genls,3)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgIsaBinaryPredicate(PRED),transitiveViaArg(PRED,genls,2)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgGenlTernaryPredicate(PRED),transitiveViaArg(PRED,genls,3)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgGenlQuantityTernaryPredicate(PRED),transitiveViaArgInverse(PRED,quantitySubsumes,3)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgGenlQuantityBinaryPredicate(PRED),transitiveViaArgInverse(PRED,quantitySubsumes,2)),iBaseKB,vStrMon).
tiny_kb(implies(rtArgGenlBinaryPredicate(PRED),transitiveViaArg(PRED,genls,2)),iBaseKB,vStrMon).
tiny_kb(implies(tMicrotheory(MT),ist(iBaseKB,tMicrotheory(MT))),iBaseKB,vStrMon).
tiny_kb(implies(tMicrotheory(MIC),genlMt(MIC,iBaseKB)),iBaseKB,vStrMon).
tiny_kb(implies(tCol(COL1),or(genls(COL1,COL2),different(COL1,COL2))),iBaseKB,vStrMon).
tiny_kb(implies(and(natFunction(NAT,FUNC),genls(COL,INDEP_COL),natArgument(NAT,ARG,COL),interArgResultGenl(FUNC,ARG,INDEP_COL,DEP_COL)),genls(NAT,DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(genls(SPEC,rtQuantifier),decontextualizedCollection(SPEC)),iBaseKB,vStrMon).
tiny_kb(implies(genls(SPEC,rtLogicalConnective),decontextualizedCollection(SPEC)),iBaseKB,vStrMon).
tiny_kb(implies(genlPreds(PRED,termDependsOn),afterRemoving(PRED,uSubLQuoteFn('REMOVE-DEPENDENT-TERM'))),iBaseKB,vStrMon).
tiny_kb(implies(genlInverse(SPEC_INVERSE,isa),afterAdding(SPEC_INVERSE,uSubLQuoteFn('PROPAGATE-INVERSE-TO-ISA'))),iBaseKB,vStrMon).
tiny_kb(implies(genlInverse(SPEC_INVERSE,genls),afterAdding(SPEC_INVERSE,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLS'))),iBaseKB,vStrMon).
tiny_kb(implies(genlInverse(SPEC_INVERSE,genlPreds),afterAdding(SPEC_INVERSE,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLPREDS'))),iBaseKB,vStrMon).
tiny_kb(implies(genlInverse(SPEC_INVERSE,genlMt),afterAdding(SPEC_INVERSE,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLMT'))),iBaseKB,vStrMon).
tiny_kb(implies(genlInverse(SPEC_INVERSE,genlInverse),afterAdding(SPEC_INVERSE,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLINVERSE'))),iBaseKB,vStrMon).
tiny_kb(ruleTemplateDirection('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate]),vForwardAssertionDirection),iBaseKB,vStrMon).
tiny_kb(afterRemoving(oldConstantName,uSubLQuoteFn('REMOVE-OLD-CONSTANT-NAME')),iBaseKB,vStrMon).
tiny_kb(afterRemoving(defnSufficient,uSubLQuoteFn('REMOVE-SUF-DEFN')),iBaseKB,vStrMon).
tiny_kb(afterAdding(trueRule,uSubLQuoteFn('ADD-TRUE-RULE')),iBaseKB,vStrMon).
tiny_kb(afterAdding(preservesGenlsInArg,uSubLQuoteFn('PGIA-AFTER-ADDING-PGIA')),iBaseKB,vStrMon).
tiny_kb(afterAdding(oldConstantName,uSubLQuoteFn('ADD-OLD-CONSTANT-NAME')),iBaseKB,vStrMon).
tiny_kb(afterAdding(elementOf,uSubLQuoteFn('CYC-ADD-ELEMENT-OF')),iBaseKB,vStrMon).
tiny_kb(afterAdding(defnSufficient,uSubLQuoteFn('ADD-SUF-DEFN')),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(quotedArgument,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(predicateConventionMt,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(ist,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(genlMt,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(definingMt,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(decontextualizedPredicate,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(collectionConventionMt,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(canonicalizerDirectiveForArgAndRest,iUniversalVocabularyImplementationMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(canonicalizerDirectiveForArg,iUniversalVocabularyImplementationMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(canonicalizerDirectiveForAllArgs,iUniversalVocabularyImplementationMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(assertionDirection,iBaseKB),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(arityMin,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(arityMax,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(arity,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(predicateConventionMt(istAsserted,iBaseKB),iBaseKB,vStrMon).
tiny_kb(negationPreds(unknownSentence,knownSentence),iBaseKB,vStrMon).
tiny_kb(instanceElementType(tSetMathematical,tThing),iBaseKB,vStrMon).
tiny_kb(fanOutArg(substring,2),iBaseKB,vStrMon).
tiny_kb(fanOutArg(genls,1),iBaseKB,vStrMon).
tiny_kb(fanOutArg(genlPreds,1),iBaseKB,vStrMon).
tiny_kb(fanOutArg(genlMt,1),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(pragmaticRequirement,pragmaticallyNormal),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(pragmaticRequirement,meetsPragmaticRequirement),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(exceptWhen,abnormal),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(exceptFor,abnormal),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(commutativeInArgs,rtCommutativeRelation),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionIsaBackchainEncouraged,isa),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionIsaBackchainEncouraged,tCol),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionGenlsBackchainEncouraged,isa),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionGenlsBackchainEncouraged,tCol),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionBackchainRequired,isa),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionBackchainRequired,tCol),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionBackchainEncouraged,isa),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(collectionBackchainEncouraged,tCol),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(abnormal,pragmaticallyNormal),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(abnormal,meetsPragmaticRequirement),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(vMonotonicallyFalse,vFalse),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(rtIrreflexiveBinaryPredicate,interArgDifferent),iBaseKB,vStrMon).
tiny_kb(conceptuallyRelated(vDefaultFalse,vFalse),iBaseKB,vStrMon).
tiny_kb(comment(iUniversalVocabularyImplementationMt,"This is the microtheory which contains the assertions about CycL terms which are necessary for Cyc's inference engine to reason about those terms."),iBaseKB,vStrMon).
tiny_kb(comment(vReformulationNeitherDirection,"A meta-property of a CycLReformulatorDirective,\nmeaning that no arg is to be interpreted as either the 'from' or 'to' arg.\nSee reformulationDirectionInMode for how this\ndirection can be used."),iBaseKB,vStrMon).
tiny_kb(comment(vReformulationForwardDirection,"A meta-property of a CycLReformulatorDirective, meaning\nthat there exist two arguments in the directive such that the\nlower-numbered arg (e.g. arg1 for a binary predicate) is the 'from'\narg, the input to the reformulator, and that the higher-numbered arg\n(e.g. arg2 for a binary predicate) is the 'to' arg, the output of the\nreformulator.  Its semantics are more fully determined by context.\nThis is the default preferredReformulationDirection for\nreformulatorRules.  See reformulationDirectionInMode for how this\ndirection can be used."),iBaseKB,vStrMon).
tiny_kb(comment(vReformulationBackwardDirection,"A meta-property of a CycLReformulatorDirective, meaning\nthat there exist two arguments in the directive such that the\nhigher-numbered arg (e.g. arg2 for a binary predicate) is the 'from'\narg, the input to the reformulator, and that the lower-numbered arg\n(e.g. arg1 for a binary predicate) is the 'to' arg, the output of the\nreformulator.  Its semantics are more fully determined by context.\nSee reformulationDirectionInMode for how this\ndirection can be used."),iBaseKB,vStrMon).
tiny_kb(comment(iQueryMt,"The instance of IndexicalConcept used specifically for referring to 'the microtheory in which this particular query is being run'.  This allows for a certain amount of reflection in queries, since it allows one to pose a query about the Microtheory of the very same Ask.  It is useful for cases where one wants to obtain certain facts about the context of an Ask without specifying anything more about that context."),iBaseKB,vStrMon).
tiny_kb(comment(iLogicalTruthMt,"This is a microtheory which contains only the assertions required to represent the logical system used in the Cyc knowledge base.  In other words, these are the assertions in CycL which must be present in order to use CycL to represent logical truths."),iBaseKB,vStrMon).
tiny_kb(comment(iLogicalTruthImplementationMt,"This is a microtheory which contains only the assertions required for the Cyc theorem prover and its underlying HL representation of the EL to function properly.  In other words, these are the assertions in CycL which are required by Cyc in order to perform any logical inferences using CycL formulas."),iBaseKB,vStrMon).
tiny_kb(comment(iInferencePSC,"A problem solving context in which all assertions in the entire KB are initially visible.  However, down each inference path, the chain of microtheories used is required to have some common descendent microtheory which is capable of inheriting all of the microtheories in the chain.  Thus, queries made in InferencePSC in effect compute locations in the space of microtheories in which the query is satisfiable.  This context is used internally by the inference engine for certain recursive calls to itself, including forward inference.  See also EverythingPSC."),iBaseKB,vStrMon).
tiny_kb(comment(ftIndeterminateTerm,"A specialization of CycLClosedDenotationalTerm.  Each instance of IndeterminateTerm is a CycL symbol for which, in oreder to establish its denotation, it is not sufficient to establish every aspect of the context of its use.\n
\nIn other words, instances of this collection are terms used to denote something which is known or assumed to exist, but whose precise identity -- i.e. which particular thing or things it is -- is unknown (unless, of course, the term is known to satisfy equals with another term whose precise identity is known).\n
\nFor instance, if Cyc knows (relationAllExists physicalExtent University SchoolCampus), and (isa MelbourneUniversity University), then Cyc knows that there is at least one instance of SchoolCampus, IndeterminateCampus, for which (physicalExtent MelbourneUniversity IndeterminateCampus) is true. This campus (or these campuses, if there happens to be more than one) would be denoted in CycL using the IndeterminateTerm:\n
\n(RelationAllExistsFn MelbourneUniversity physicalExtent University SchoolCampus).\n
\nAnalogously, instances of SkolemTerm are also instances of IndeterminateTerm, as are terms built from SomeFn, GenericInstanceFn, ArbitraryInstanceFn, et al (see the specialization NonSkolemIndeterminateTerm)."),iBaseKB,vStrMon).
tiny_kb(comment(iEverythingPSC,"A problem solving context in which all assertions in the entire KB are visible.  This context is only appropriate for use in queries which do not care about the consequences of possible contradictions due to conflicting information from mutually inconsistent microtheories.  See also InferencePSC."),iBaseKB,vStrMon).
tiny_kb(comment(iAuthorDefinitionalMt,"The microtheory in which instances of Cyclist are defined.  Assertions about them belong in CyclistsMt."),iBaseKB,vStrMon).
tiny_kb(comment(vAdministrator,"This constant is for use by Cyc administrators responsible for installation, setup and maintenance of Cyc images."),iBaseKB,vStrMon).
tiny_kb(comment(iCurrentWorldDataCollectorMtNonHomocentric,"The Microtheory which collects together all of the instances of GeneralMicrotheory (including instances of DataMicrotheory) as genlMts (excepting HomoCentricNaturalismMt), so that any scenario or project microtheory which needs wide access to the KB but needs to accept either non-human Persons or supernatural things can use this as a genlMt and be assured that all generally defined terms are available.  If no need exists to access instances of TemporalThing, WorldLikeOursCollectorMt-NonHomocentric should be used instead.  If for the purposes of the project all persons are human and no supernatural things are being reasoned about use the CollectorMicrotheory CurrentWorldDataCollectorMt or WorldLikeOursCollectorMt."),iBaseKB,vStrMon).
tiny_kb(comment(iCoreCycLMt,"This is a microtheory which contains only the assertions required to represent useful logical truths in CycL.  It extends the LogicalTruthMt with additional assertions which are so useful as to be considered `core' to the CycL language."),iBaseKB,vStrMon).
tiny_kb(comment(iCoreCycLImplementationMt,"This is a microtheory which contains only the `core' assertions required for the Cyc theorem prover and its underlying HL representation of the EL to conclude useful inferences.  It extends the LogicalTruthImplementationMt with assertions necessary for Cyc's implementation to make use of the terms defined in the CoreCycLMt."),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtVariableAritySkolemFunction,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(tThing,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftTheTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSymbol,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftString,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSubLSExpression,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftRealNumber,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonVariableSymbol,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonVariableNonKeywordSymbol,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftList,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftKeyword,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftInt,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ttExpressionType,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftCharacter,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtom,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtSkolemFunction,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtSententialRelation,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtInferenceRelatedBookkeepingPredicate,iBaseKB),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(xtHLExternalIDString,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(vExistentialQuantifierBounded,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(iELRelationReversible,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtELRelation,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftVar,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftTruthValueSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftExpression,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentenceAssertible,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentenceAskable,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftRuleAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftRepresentedTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftRepresentedAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftReifiedDenotationalTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftReifiableNonAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftReifiableDenotationalTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftPropositionalSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftCycLOpenExpression,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftDenotationalTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonAtomicTermAssertible,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonAtomicTermAskable,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftNonAtomicReifiedTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftIndexedTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftGenericRelationFormula,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftGAFAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftExpressionAssertible,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftExpressionAskable,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftCycLExpression,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftDenotationalTermAssertible,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftDenotationalTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftDeducedAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftConstant,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftClosedSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftClosedNonAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftClosedFormula,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftCycLClosedExpression,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftClosedDenotationalTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftClosedAtomicSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtomicTerm,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtomicSentence,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAtomicAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(ftAssertedAssertion,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(vtCanonicalizerDirective,iCoreCycLImplementationMt),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(mtBroadMicrotheory,iBaseKB),iBaseKB,vStrMon).
tiny_kb(collectionConventionMt(rtArgQuotedIsaTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrMon).
tiny_kb(implies(nearestDifferentIsa(OBJ_1,OBJ_2,NEAR_DIFF),isa(OBJ_1,NEAR_DIFF)),iBaseKB,vStrMon).
tiny_kb(implies(nearestDifferentGenls(COL_1,COL_2,NEAR_DIFF),genls(COL_1,NEAR_DIFF)),iBaseKB,vStrMon).
tiny_kb(implies(nearestCommonIsa(OBJ,OBJ,NEAR_ISA),nearestIsa(OBJ,NEAR_ISA)),iBaseKB,vStrMon).
tiny_kb(implies(nearestCommonGenls(COL,COL,NEAR_GENL),nearestGenls(COL,NEAR_GENL)),iBaseKB,vStrMon).
tiny_kb(implies(nearestCommonGenlMt(MT,MT,NEAR_MT),nearestGenlMt(MT,NEAR_MT)),iBaseKB,vStrMon).
tiny_kb(implies(quotedIsa(EXPR,ftCycLClosedExpression),equals(xQuoteFn(EXPR),xQuoteFn(xEscapeQuoteFn(EXPR)))),iBaseKB,vStrMon).
tiny_kb(implies(pointQuantValue(SCALAR,VALUE),minQuantValue(SCALAR,VALUE)),iBaseKB,vStrMon).
tiny_kb(implies(pointQuantValue(SCALAR,VALUE),maxQuantValue(SCALAR,VALUE)),iBaseKB,vStrMon).
tiny_kb(implies(multiplicationUnits(UNIT1,UNIT2,PROD_UNIT),multiplicationUnits(UNIT1,UNIT2,PROD_UNIT)),iBaseKB,vStrMon).
tiny_kb(implies(rtExceptionPredicate(CONNECT),abnormal(vTheListFn(CONNECT,ARITY,ARG_N_QUOTED_ISA,N,ARG_N_ISA),'TINYKB-ASSERTION'(':TRUE-MON',[[[isa,CONNECT,rtFixedArityRelation],[isa,CONNECT,rtLogicalConnective],[arity,CONNECT,ARITY],[isa,ARG_N_QUOTED_ISA,rtArgQuotedIsaBinaryPredicate],[constrainsArg,ARG_N_QUOTED_ISA,N],[integerBetween,1,N,ARITY]],[[ARG_N_QUOTED_ISA,CONNECT,ftSentenceAssertible]]],iBaseKB,s("?CONNECT","?ARITY","?ARG-N-QUOTED-ISA","?N"),[implies,[and,[isa,CONNECT,rtFixedArityRelation],[isa,CONNECT,rtLogicalConnective],[arity,CONNECT,ARITY],[isa,ARG_N_QUOTED_ISA,rtArgQuotedIsaBinaryPredicate],[constrainsArg,ARG_N_QUOTED_ISA,N],[integerBetween,1,N,ARITY]],[ARG_N_QUOTED_ISA,CONNECT,ftSentenceAssertible]]))),iBaseKB,vStrMon).
tiny_kb(implies(vtScalarInterval(INSTANCE),abnormal(vTheListFn(PRED,COLLECTION,INSTANCE),'TINYKB-ASSERTION'(':TRUE-MON',[[[relationAllInstance,PRED,COLLECTION,INSTANCE]],[[conceptuallyRelated,COLLECTION,INSTANCE]]],iBaseKB,s("?PRED","?COLLECTION","?INSTANCE"),[implies,[relationAllInstance,PRED,COLLECTION,INSTANCE],[conceptuallyRelated,COLLECTION,INSTANCE]]))),iBaseKB,vStrMon).
tiny_kb(implies(natArgument(NAT,0,FUNCTION),natFunction(NAT,FUNCTION)),iBaseKB,vStrMon).
tiny_kb(implies(and(trueSentence(FORMULA),interArgDifferent(FORMULAARGFN_2,ARG_1,ARG_2),evaluate(FORMULAARGFN_2,uFormulaArgFn(0,FORMULA)),evaluate(FORMULAARGFN,uFormulaArgFn(ARG_1,FORMULA)),evaluate(FORMULAARGFN_1,uFormulaArgFn(ARG_2,FORMULA))),different(FORMULAARGFN,FORMULAARGFN_1)),iBaseKB,vStrMon).
tiny_kb(implies(and(trueSentence(ANTE),sentenceImplies(ANTE,CONSEQ)),trueSentence(CONSEQ)),iBaseKB,vStrMon).
tiny_kb(implies(and(relationAllExistsCount(PRED,ARG1,ARG2,N),relationAllExistsMin(PRED,ARG1,ARG2,M)),greaterThanOrEqualTo(N,M)),iBaseKB,vStrMon).
tiny_kb(implies(and(relationAll(PRED,COL),isa(OBJ,COL)),isa(OBJ,PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(numericallyEquals(M,N),relationAllExistsCount(REL,COL1,COL2,N)),relationAllExistsCount(REL,COL1,COL2,M)),iBaseKB,vStrMon).
tiny_kb(implies(and(unitMultiplicationFactor(UNIT_TWO,UNIT_THREE,FACTOR1),termOfUnit(PERFN_1,cycPerFn(UNIT_ONE,UNIT_THREE)),termOfUnit(PERFN,cycPerFn(UNIT_ONE,UNIT_TWO))),unitMultiplicationFactor(PERFN_1,PERFN,FACTOR1)),iBaseKB,vStrMon).
tiny_kb(implies(and(unitMultiplicationFactor(SMALL,BIG,FACTOR),evaluate(TIMESFN,vTimesFn(FACTOR,N))),equals(isa(N,BIG),isa(TIMESFN,SMALL))),iBaseKB,vStrMon).
tiny_kb(implies(call_u_no_bc(genlPreds(SPEC,PRED)),meetsPragmaticRequirement(vTheListFn(PRED,SPEC),'TINYKB-ASSERTION'(':TRUE-MON',[[[decontextualizedPredicate,PRED],[genlPreds,SPEC,PRED]],[[decontextualizedPredicate,SPEC]]],iBaseKB,s("?PRED","?SPEC"),[implies,[and,[decontextualizedPredicate,PRED],[genlPreds,SPEC,PRED]],[decontextualizedPredicate,SPEC]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(negationPreds(GENL_PRED,NEG_PRED),genlPreds(SPEC_PRED,GENL_PRED)),negationPreds(NEG_PRED,SPEC_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(negationPreds(GENL_PRED,NEG_PRED),genlInverse(SPEC_PRED,GENL_PRED)),negationInverse(NEG_PRED,SPEC_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(negationInverse(GENL_PRED,NEG_PRED),genlPreds(SPEC_PRED,GENL_PRED)),negationInverse(NEG_PRED,SPEC_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(negationInverse(GENL_PRED,NEG_PRED),genlInverse(SPEC_PRED,GENL_PRED)),negationPreds(NEG_PRED,SPEC_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(maxQuantValue(ATT,isa(VAL,UNIT)),minQuantValue(ATT,isa(VAL,UNIT))),equals(ATT,isa(VAL,UNIT))),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(X,COL1),trueSentence(all(Y,or(isa(Y,COL2),~isa(Y,COL1))))),isa(X,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT1),ttUnitOfMeasure(UNIT2),evaluate(TIMESFN,vTimesFn(isa(NUM2,UNIT1),isa(NUM1,UNIT2))),evaluate(TIMESFN_1,vTimesFn(isa(NUM1,UNIT1),isa(NUM2,UNIT2)))),equals(TIMESFN,TIMESFN_1)),iBaseKB,vStrMon).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),vtScalarIntegralValue(t(UNIT,M)),vtScalarIntegralValue(t(UNIT,N)),evaluate(TIMESFN,vTimesFn(isa(M,UNIT),isa(N,UNIT)))),vtScalarIntegralValue(TIMESFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),vtScalarIntegralValue(t(UNIT,M)),vtScalarIntegralValue(t(UNIT,N)),evaluate(PLUSFN,vPlusFn(isa(M,UNIT),isa(N,UNIT)))),vtScalarIntegralValue(PLUSFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(THING,COL1),coExtensional(COL1,COL2)),isa(THING,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(TERM,INDEP_COL),relationExistsAll(PRED,DEP_COL,INDEP_COL)),isa(uRelationExistsAllFn(TERM,PRED,DEP_COL,INDEP_COL),DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(TERM,INDEP_COL),relationExistsAll(PRED,DEP_COL,INDEP_COL)),t(PRED,uRelationExistsAllFn(TERM,PRED,DEP_COL,INDEP_COL),TERM)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(TERM,INDEP_COL),relationAllExists(PRED,INDEP_COL,DEP_COL)),isa(uRelationAllExistsFn(TERM,PRED,INDEP_COL,DEP_COL),DEP_COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(TERM,INDEP_COL),relationAllExists(PRED,INDEP_COL,DEP_COL)),t(PRED,TERM,uRelationAllExistsFn(TERM,PRED,INDEP_COL,DEP_COL))),iBaseKB,vStrMon).
tiny_kb(implies(and(rtReflexiveBinaryPredicate(SPEC_PRED),genlInverse(SPEC_PRED,GENL_PRED),different(GENL_PRED,SPEC_PRED),argIsa(SPEC_PRED,1,ARG1ISA),argIsa(GENL_PRED,2,ARG1ISA),argIsa(SPEC_PRED,2,ARG2ISA),argIsa(GENL_PRED,1,ARG2ISA)),rtReflexiveBinaryPredicate(GENL_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtCommutativeRelation(RELN),arity(RELN,ARITY),integerBetween(0,M,ARITY),different(M,N),integerBetween(0,N,ARITY)),commutativeInArgs(RELN,M,N)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtTransitiveBinaryPredicate(PRED),relationExistsAll(PRED,COL1,COL2),relationExistsAll(PRED,COL2,COL3)),relationExistsAll(PRED,COL1,COL3)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtReflexiveBinaryPredicate(PRED),argIsa(PRED,1,CONSTRAINT1),isa(OBJ1,CONSTRAINT1),equals(OBJ1,OBJ2)),t(PRED,OBJ1,OBJ2)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtReflexiveBinaryPredicate(PRED),admittedArgument(THING,1,PRED),admittedArgument(THING,2,PRED),equals(SAMETHING,THING)),t(PRED,THING,SAMETHING)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtReflexiveBinaryPredicate(PRED),admittedArgument(OBJ,1,PRED),admittedArgument(OBJ,2,PRED)),t(PRED,OBJ,OBJ)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtBinaryPredicate(PRED),rtCommutativeRelation(PRED)),rtSymmetricBinaryPredicate(PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtBinaryPredicate(PRED),argIsa(PRED,2,COL2),requiredArg1Pred(COL1,PRED)),relationAllExists(PRED,COL1,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(vtScalarPointValue(POINT1),minQuantValue(POINT1,POINT2)),equals(POINT1,POINT2)),iBaseKB,vStrMon).
tiny_kb(implies(and(vtScalarPointValue(POINT1),maxQuantValue(POINT1,POINT2)),equals(POINT1,POINT2)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(OBJ,SUBSET),genls(SUBSET,SUPERSET)),isa(OBJ,SUPERSET)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(OBJ,COL_2),relationExistsAll(PRED,COL_1,COL_2)),relationExistsInstance(PRED,COL_1,OBJ)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(OBJ,COL_1),relationAllExists(PRED,COL_1,COL_2)),relationInstanceExists(PRED,OBJ,COL_2)),iBaseKB,vStrMon).
tiny_kb(implies(and(ftInt(NUM),vtScalarIntegralValue(t(UNIT1,M)),vtScalarIntegralValue(t(UNIT2,N)),unitMultiplicationFactor(UNIT1,UNIT2,NUM),evaluate(TIMESFN,vTimesFn(isa(M,UNIT1),isa(N,UNIT2)))),vtScalarIntegralValue(TIMESFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(ftInt(NUM),vtScalarIntegralValue(t(UNIT1,M)),vtScalarIntegralValue(t(UNIT2,N)),unitMultiplicationFactor(UNIT1,UNIT2,NUM),evaluate(PLUSFN,vPlusFn(isa(M,UNIT1),isa(N,UNIT2)))),vtScalarIntegralValue(PLUSFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(ftInt(NUM),vtScalarIntegralValue(t(UNIT1,M)),vtScalarIntegralValue(t(UNIT2,N)),unitMultiplicationFactor(UNIT1,UNIT2,NUM),evaluate(DIFFERENCEFN,vDifferenceFn(isa(M,UNIT1),isa(N,UNIT2)))),vtScalarIntegralValue(DIFFERENCEFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(ftInt(INT),ttUnitOfMeasure(UNIT)),vtScalarIntegralValue(t(UNIT,INT))),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(INST,COL2),relationAllInstance(PRED,COL1,INST)),relationAllExists(PRED,COL1,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(arityMax(RELN,MAX),arityMin(RELN,MIN)),greaterThanOrEqualTo(MAX,MIN)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(RELN,5),rtCommutativeRelation(RELN)),commutativeInArgs(RELN,1,2,3,4,5)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(RELN,4),rtCommutativeRelation(RELN)),commutativeInArgs(RELN,1,2,3,4)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(RELN,3),rtCommutativeRelation(RELN)),commutativeInArgs(RELN,1,2,3)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(RELN,2),rtCommutativeRelation(RELN)),commutativeInArgs(RELN,1,2)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtLogicalConnective(CONNECT),rtVariableArityRelation(CONNECT)),argsQuotedIsa(CONNECT,ftSentenceAssertible)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtFixedArityRelation(CONNECT),rtLogicalConnective(CONNECT),arity(CONNECT,ARITY),rtArgQuotedIsaBinaryPredicate(ARG_N_QUOTED_ISA),constrainsArg(ARG_N_QUOTED_ISA,N),integerBetween(1,N,ARITY)),t(ARG_N_QUOTED_ISA,CONNECT,ftSentenceAssertible)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtAssociativeRelation(FUNC),tFunction(FUNC),resultIsa(FUNC,RESULTCOL),argIsa(FUNC,_N,ARGCOL)),genls(RESULTCOL,ARGCOL)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtAssociativeRelation(FUNC),tFunction(FUNC),argIsa(FUNC,_N,ARGCOL)),argIsa(FUNC,_M,ARGCOL)),iBaseKB,vStrMon).
tiny_kb(implies(and(rtAssociativeRelation(FUNC),rtBinaryFunction(FUNC)),equals(t(FUNC,THING1,t(FUNC,THING2,THING3)),t(FUNC,THING3,t(FUNC,THING1,THING2)))),iBaseKB,vStrMon).
tiny_kb(implies(and(rtBinaryPredicate(BINPRED),argIsa(BINPRED,1,COL2),requiredArg2Pred(COL1,BINPRED)),relationExistsAll(BINPRED,COL2,COL1)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(ALL_INST,ALL_COL),relationAllExists(PRED,ALL_COL,EX_COL)),trueSentence(exists(EX_INST,and(isa(EX_INST,EX_COL),t(PRED,ALL_INST,EX_INST))))),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(_ANY,COL),relationAllInstance(PRED,COL,INST)),relationExistsInstance(PRED,COL,INST)),iBaseKB,vStrMon).
tiny_kb(implies(and(isa(ARG1,PRED),genlPreds(PRED,GENL_PRED)),isa(ARG1,GENL_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(greaterThanOrEqualTo(MAX,MIN),maxQuantValue(ATT,isa(MAX,UNIT)),minQuantValue(ATT,isa(MIN,UNIT))),equals(ATT,t(UNIT,MIN,MAX))),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(SPEC,COL2),different(COL2,SPEC),relationAllExists(PRED,COL1,SPEC)),abnormal(vTheListFn(PRED,COL1,COL2),'TINYKB-ASSERTION'(':TRUE-MON',[[[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[[relationAllExists,PRED,COL1,COL2]]],iBaseKB,s("?PRED","?COL1","?COL2"),[implies,[and,[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[relationAllExists,PRED,COL1,COL2]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(SPEC,COL),defnNecessary(COL,DEFN)),defnNecessary(SPEC,DEFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(COL_1,DIFF_NEAR),different(COL_1,DIFF_NEAR)),or(elementOf(COL_2,tSetOfTheSetOfFn(ITEM_1,genls(ITEM_1,DIFF_NEAR))),nearestDifferentGenls(COL_1,COL_2,DIFF_NEAR),elementOf(DIFF_NEAR,tSetOfTheSetOfFn(DIFF_FARTHER,exists(DIFF_FAR,and(genls(COL_1,DIFF_FAR),genls(DIFF_FAR,DIFF_FARTHER),different(COL_1,DIFF_FAR),different(DIFF_FAR,DIFF_FARTHER),not(elementOf(COL_2,tSetOfTheSetOfFn(ITEM_2,genls(ITEM_2,DIFF_FAR)))),not(elementOf(COL_2,tSetOfTheSetOfFn(ITEM_3,genls(ITEM_3,DIFF_FARTHER)))))))))),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(COL2,COL3),argIsa(PRED,2,COL3)),meetsPragmaticRequirement(vTheListFn(PRED,COL1,COL2),'TINYKB-ASSERTION'(':TRUE-MON',[[[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[[relationAllExists,PRED,COL1,COL2]]],iBaseKB,s("?PRED","?COL1","?COL2"),[implies,[and,[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[relationAllExists,PRED,COL1,COL2]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(COL1,GENL),different(COL1,GENL),relationAllExists(PRED,GENL,COL2)),abnormal(vTheListFn(PRED,COL1,COL2),'TINYKB-ASSERTION'(':TRUE-MON',[[[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[[relationAllExists,PRED,COL1,COL2]]],iBaseKB,s("?PRED","?COL1","?COL2"),[implies,[and,[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[relationAllExists,PRED,COL1,COL2]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(COL1,COL2),genls(COL2,COL1)),coExtensional(COL1,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(genls(COL,GENL),defnSufficient(COL,DEFN)),defnSufficient(GENL,DEFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(SPEC_PRED,PRED),genlInverse(PRED,GENL_PRED)),genlInverse(SPEC_PRED,GENL_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(SPEC_PRED,PRED),different(PRED,SPEC_PRED),relationAllExists(SPEC_PRED,COL1,COL2)),abnormal(vTheListFn(PRED,COL1,COL2),'TINYKB-ASSERTION'(':TRUE-MON',[[[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[[relationAllExists,PRED,COL1,COL2]]],iBaseKB,s("?PRED","?COL1","?COL2"),[implies,[and,[arity,PRED,2],[requiredArg1Pred,COL1,PRED],[interArgIsa1_2,PRED,COL1,COL2]],[relationAllExists,PRED,COL1,COL2]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(SPEC_PRED,GENL_PRED),different(GENL_PRED,SPEC_PRED),relationInstanceAll(SPEC_PRED,ARG1,ARG2)),relationInstanceAll(GENL_PRED,ARG1,ARG2)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(SPEC_PRED,GENL_PRED),different(GENL_PRED,SPEC_PRED),relationAllInstance(SPEC_PRED,ARG1,ARG2)),relationAllInstance(GENL_PRED,ARG1,ARG2)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(PRED,NEAR_PRED),different(NEAR_PRED,PRED),unknownSentence(exists(BETWEEN,and(genlPreds(BETWEEN,NEAR_PRED),genlPreds(PRED,BETWEEN),different(BETWEEN,NEAR_PRED,PRED))))),nearestGenlPreds(PRED,NEAR_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(PRED,GENL_PRED),t(PRED,ARG1,ARG2,ARG3,ARG4,ARG5)),t(GENL_PRED,ARG1,ARG2,ARG3,ARG4,ARG5)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(PRED,GENL_PRED),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(GENL_PRED,ARG1,ARG2,ARG3,ARG4)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(PRED,GENL_PRED),t(PRED,ARG1,ARG2,ARG3)),t(GENL_PRED,ARG1,ARG2,ARG3)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlPreds(PRED,GENL_PRED),t(PRED,ARG1,ARG2)),t(GENL_PRED,ARG1,ARG2)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlMt(MT_1,COMMON_NEAR),different(COMMON_NEAR,MT_1),different(COMMON_NEAR,MT_2),genlMt(MT_2,COMMON_NEAR)),or(nearestCommonGenlMt(MT_1,MT_2,COMMON_NEAR),elementOf(COMMON_NEAR,tSetOfTheSetOfFn(COMMON_FARTHER,exists(COMMON_FAR,and(genlMt(COMMON_FAR,COMMON_FARTHER),genlMt(MT_1,COMMON_FAR),genlMt(MT_2,COMMON_FAR),different(COMMON_FAR,COMMON_FARTHER),different(COMMON_FAR,MT_1),different(COMMON_FAR,MT_2))))))),iBaseKB,vStrMon).
tiny_kb(implies(and(genlInverse(SPEC_PRED,PRED),genlPreds(PRED,GENL_PRED)),genlInverse(SPEC_PRED,GENL_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlInverse(SPEC_PRED,PRED),genlInverse(PRED,GENL_PRED)),genlPreds(SPEC_PRED,GENL_PRED)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlInverse(PRED,INVERSE),relationExistsAll(PRED,TYPE1,TYPE2)),relationAllExists(INVERSE,TYPE2,TYPE1)),iBaseKB,vStrMon).
tiny_kb(implies(and(genlInverse(PRED,GENL_INV_PRED),t(PRED,ARG1,ARG2)),t(GENL_INV_PRED,ARG2,ARG1)),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(TIMESFN,vTimesFn(isa(1,UNIT2),isa(N,UNIT1))),termOfUnit(UNITPRODUCTFN,cycUnitProductFn(UNIT1,UNIT2))),equals(TIMESFN,isa(N,UNITPRODUCTFN))),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(TERM,uFormulaArgFn(ARG,NAT)),termOfUnit(NAT,FORMULA)),natArgument(NAT,ARG,TERM)),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(QUOTIENTFN,vQuotientFn(isa(N,UNIT1),isa(1,UNIT2))),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT2))),equals(QUOTIENTFN,isa(N,PERFN))),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(QUOTIENTFN,vQuotientFn(t(UNIT1,M,N),isa(1,UNIT2))),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT2))),equals(QUOTIENTFN,t(PERFN,M,N))),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(ARGS_LIST,vFormulaArgListFn(NAT1)),evaluate(ARGS_LIST,vFormulaArgListFn(NAT2)),termOfUnit(NAT1,FORMULA1),termOfUnit(NAT2,FORMULA2)),natArgumentsEqual(NAT1,NAT2)),iBaseKB,vStrMon).
tiny_kb(implies(and(evaluate(ARG,uFormulaArgFn(N,NAT)),termOfUnit(NAT,FORMULA)),termDependsOn(NAT,ARG)),iBaseKB,vStrMon).
tiny_kb(implies(evaluate(TIMESFN,vTimesFn(X,0)),evaluate(0,TIMESFN)),iBaseKB,vStrMon).
tiny_kb(implies(evaluate(PLUSFN,vPlusFn(X,0)),equals(PLUSFN,X)),iBaseKB,vStrMon).
tiny_kb(implies(evaluate(PLUSFN,vPlusFn(X)),equals(PLUSFN,X)),iBaseKB,vStrMon).
tiny_kb(implies(evaluate(_RESULT,uEvaluateSubLFn(SUBL)),performSubL(SUBL)),iBaseKB,vStrMon).
tiny_kb(implies(different(UNIT_THREE,UNIT_TWO),meetsPragmaticRequirement(vTheListFn(UNIT_TWO,UNIT_THREE,FACTOR1,PERFN_1,UNIT_ONE,PERFN),'TINYKB-ASSERTION'(':TRUE-MON',[[[unitMultiplicationFactor,UNIT_TWO,UNIT_THREE,FACTOR1],[termOfUnit,PERFN_1,[cycPerFn,UNIT_ONE,UNIT_THREE]],[termOfUnit,PERFN,[cycPerFn,UNIT_ONE,UNIT_TWO]]],[[unitMultiplicationFactor,PERFN_1,PERFN,FACTOR1]]],iBaseKB,s("?UNIT-TWO","?UNIT-THREE","?FACTOR1","?PERFN-1","?UNIT-ONE","?PERFN"),[implies,[and,[unitMultiplicationFactor,UNIT_TWO,UNIT_THREE,FACTOR1],[termOfUnit,PERFN_1,[cycPerFn,UNIT_ONE,UNIT_THREE]],[termOfUnit,PERFN,[cycPerFn,UNIT_ONE,UNIT_TWO]]],[unitMultiplicationFactor,PERFN_1,PERFN,FACTOR1]]))),iBaseKB,vStrMon).
tiny_kb(implies(different(UNIT_ONE,UNIT_TWO),meetsPragmaticRequirement(vTheListFn(UNIT_ONE,UNIT_TWO,FACTOR1,PERFN_1,UNIT_THREE,PERFN),'TINYKB-ASSERTION'(':TRUE-DEF',[[[unitMultiplicationFactor,UNIT_ONE,UNIT_TWO,FACTOR1],[termOfUnit,PERFN_1,[cycPerFn,UNIT_ONE,UNIT_THREE]],[termOfUnit,PERFN,[cycPerFn,UNIT_TWO,UNIT_THREE]]],[[unitMultiplicationFactor,PERFN_1,PERFN,FACTOR1]]],iBaseKB,s("?UNIT-ONE","?UNIT-TWO","?FACTOR1","?PERFN-1","?UNIT-THREE","?PERFN"),[implies,[and,[unitMultiplicationFactor,UNIT_ONE,UNIT_TWO,FACTOR1],[termOfUnit,PERFN_1,[cycPerFn,UNIT_ONE,UNIT_THREE]],[termOfUnit,PERFN,[cycPerFn,UNIT_TWO,UNIT_THREE]]],[unitMultiplicationFactor,PERFN_1,PERFN,FACTOR1]]))),iBaseKB,vStrMon).
tiny_kb(implies(and(disjointWith(COL,SUPERSET),genls(SUBSET,SUPERSET)),disjointWith(COL,SUBSET)),iBaseKB,vStrMon).
tiny_kb(implies(and(different(negationPreds,SPEC_PRED),genlPreds(SPEC_PRED,negationPreds)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-NEGATIONPREDS'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(negationInverse,SPEC_PRED),genlPreds(SPEC_PRED,negationInverse)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-NEGATIONINVERSE'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(isa,SPEC_PRED),genlPreds(SPEC_PRED,isa)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-ISA'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(genls,SPEC_PRED),genlPreds(SPEC_PRED,genls)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-GENLS'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(genlPreds,SPEC_PRED),genlPreds(SPEC_PRED,genlPreds)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-GENLPREDS'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(genlMt,SPEC_PRED),genlPreds(SPEC_PRED,genlMt)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-GENLMT'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(genlInverse,SPEC_PRED),genlPreds(SPEC_PRED,genlInverse)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-GENLINVERSE'))),iBaseKB,vStrMon).
tiny_kb(implies(and(different(vFalse,EVALUATESUBLFN),evaluate(EVALUATESUBLFN,uEvaluateSubLFn(uExpandSubLFn(RESULT,'FIF'('QUOTE'(RESULT),vTrue,vFalse)))),evaluate(RESULT,uEvaluateSubLFn(SUBL))),trueSubL(SUBL)),iBaseKB,vStrMon).
tiny_kb(implies(and(different(MT,NEAR_MT),genlMt(MT,NEAR_MT),unknownSentence(exists(BETWEEN,and(genlMt(BETWEEN,NEAR_MT),genlMt(MT,BETWEEN),different(BETWEEN,MT,NEAR_MT))))),nearestGenlMt(MT,NEAR_MT)),iBaseKB,vStrMon).
tiny_kb(implies(and(different(GENL_COL,SPEC_COL),genls(SPEC_COL,GENL_COL),relationInstanceAll(PRED,ARG,GENL_COL)),relationInstanceAll(PRED,ARG,SPEC_COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(different(GENL_COL,SPEC_COL),genls(SPEC_COL,GENL_COL),relationAllInstance(PRED,GENL_COL,ARG)),relationAllInstance(PRED,SPEC_COL,ARG)),iBaseKB,vStrMon).
tiny_kb(implies(and(decontextualizedPredicate(SPEC_PRED),genlPreds(SPEC_PRED,genlMt)),predicateConventionMt(SPEC_PRED,iUniversalVocabularyMt)),iBaseKB,vStrMon).
tiny_kb(implies(and(decontextualizedPredicate(PRED),genlPreds(SPEC,PRED)),decontextualizedPredicate(SPEC)),iBaseKB,vStrMon).
tiny_kb(implies(and(decontextualizedPredicate(PRED),different(PRED,SPEC),genlInverse(SPEC,PRED),predicateConventionMt(PRED,MT)),predicateConventionMt(SPEC,MT)),iBaseKB,vStrMon).
tiny_kb(implies(and(decontextualizedPredicate(PRED),different(PRED,SPEC),genlInverse(SPEC,PRED)),decontextualizedPredicate(SPEC)),iBaseKB,vStrMon).
tiny_kb(implies(and(call_u_no_bc(isa(ARG,COL)),natFunction(NART,FUNC),resultIsaArgIsa(FUNC,INT),natArgument(NART,INT,ARG)),isa(NART,COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(call_u_no_bc(genls(SPEC,GENL)),genls(GENL,SPEC),different(GENL,SPEC)),coExtensional(GENL,SPEC)),iBaseKB,vStrMon).
tiny_kb(implies(and(call_u_no_bc(FORMULA),evaluate(FORMULAARGFN,uFormulaArgFn(0,FORMULA)),evaluate(FORMULAARGFN_1,uFormulaArgFn(ARG,FORMULA))),assertedPredicateArg(FORMULAARGFN_1,ARG,FORMULAARGFN)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(PRED,2),requiredArg1Pred(COL1,PRED),interArgIsa(PRED,1,COL1,2,COL2)),relationAllExists(PRED,COL1,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(and(arity(PRED,M),evaluate(M_1,vDifferenceFn(M,1))),arity(iFunctionToArgFn(N,PRED),M_1)),iBaseKB,vStrMon).
tiny_kb(implies(and(argIsa(PRED,2,TYPE),relationAllInstance(PRED,COL,ARG2)),isa(ARG2,TYPE)),iBaseKB,vStrMon).
tiny_kb(implies(and(argIsa(PRED,2,COL),relationExistsInstance(PRED,_DUMMY,THING)),isa(THING,COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(argIsa(PRED,1,TYPE),relationInstanceAll(PRED,ARG1,COL)),isa(ARG1,TYPE)),iBaseKB,vStrMon).
tiny_kb(implies(and(argIsa(PRED,1,COL),relationInstanceExists(PRED,THING,_DUMMY)),isa(THING,COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(argIsa(PRED,1,COL),t(PRED,THING,_DUMMY)),isa(THING,COL)),iBaseKB,vStrMon).
tiny_kb(implies(and(argGenl(PRED,1,COL2),relationAllInstance(PRED,_ARG1,ARG2)),isa(ARG2,COL2)),iBaseKB,vStrMon).
tiny_kb(implies(unknownSentence(exists(SOME_MT,predicateConventionMt(SPEC,SOME_MT))),meetsPragmaticRequirement(vTheListFn(PRED,SPEC,MT),'TINYKB-ASSERTION'(':TRUE-MON',[[[decontextualizedPredicate,PRED],[different,PRED,SPEC],[genlInverse,SPEC,PRED],[predicateConventionMt,PRED,MT]],[[predicateConventionMt,SPEC,MT]]],iBaseKB,s("?PRED","?SPEC","?MT"),[implies,[and,[decontextualizedPredicate,PRED],[different,PRED,SPEC],[genlInverse,SPEC,PRED],[predicateConventionMt,PRED,MT]],[predicateConventionMt,SPEC,MT]]))),iBaseKB,vStrMon).
tiny_kb(implies(relationInstanceExists(PRED,THING,COLL),isa(uRelationInstanceExistsFn(PRED,THING,COLL),COLL)),iBaseKB,vStrMon).
tiny_kb(implies(relationInstanceExists(PRED,THING,COLL),t(PRED,THING,uRelationInstanceExistsFn(PRED,THING,COLL))),iBaseKB,vStrMon).
tiny_kb(implies(relationInstanceAll(PRED,THING,COL),trueSentence(implies(isa(INST,COL),t(PRED,THING,INST)))),iBaseKB,vStrMon).
tiny_kb(implies(relationInstanceAll(PRED,INSTANCE,COLLECTION),conceptuallyRelated(COLLECTION,INSTANCE)),iBaseKB,vStrMon).
tiny_kb(implies(relationExistsInstance(PRED,COLL,THING),isa(uRelationExistsInstanceFn(PRED,COLL,THING),COLL)),iBaseKB,vStrMon).
tiny_kb(implies(relationExistsInstance(PRED,COLL,THING),t(PRED,uRelationExistsInstanceFn(PRED,COLL,THING),THING)),iBaseKB,vStrMon).
tiny_kb(implies(relationAllInstance(PRED,COLLECTION,INSTANCE),conceptuallyRelated(COLLECTION,INSTANCE)),iBaseKB,vStrMon).
tiny_kb(implies(relationAllInstance(PRED,COL1,_COL2),requiredArg1Pred(COL1,PRED)),iBaseKB,vStrMon).
tiny_kb(implies(relationAll(PRED,COL),trueSentence(implies(isa(INST,COL),isa(INST,PRED)))),iBaseKB,vStrMon).
tiny_kb(implies(and(resultGenl(FUNC,COL),equals(VALUE,'NART'([FUNC|ARGS]))),genls(VALUE,COL)),iBaseKB,vStrMon).
tiny_kb(implies(t([commutativeInArgs,_PRED|ARGS]),t([different|ARGS])),iBaseKB,vStrMon).
tiny_kb(implies(and(resultIsa(FUNC,COL),equals(VALUE,'NART'([FUNC|ARGS]))),isa(VALUE,COL)),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(termOfUnit),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(quotedArgument),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(predicateConventionMt),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(notAssertibleMt),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(ist),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(genlMt),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(ephemeralTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(definingMt),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(decontextualizedPredicate),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(decontextualizedCollection),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(collectionConventionMt),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(canonicalizerDirectiveForArg),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(canonicalizerDirectiveForAllArgs),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(assertionDirection),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(arityMin),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(arityMax),iBaseKB,vStrMon).
tiny_kb(decontextualizedPredicate(arity),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtVariableAritySkolemFunction),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(tThing),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftTheTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSymbol),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftString),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSubLSExpression),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftRealNumber),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonVariableSymbol),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonVariableNonKeywordSymbol),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftList),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftKeyword),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftInt),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ttExpressionType),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftCharacter),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtom),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtSkolemFunction),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtSententialRelation),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(tMicrotheory),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtInferenceRelatedBookkeepingPredicate),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(xtHLExternalIDString),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(vExistentialQuantifierBounded),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(iELRelationReversible),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtELRelation),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftVar),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftTruthValueSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftExpression),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentenceAssertible),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentenceAskable),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftRuleAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftRepresentedTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftRepresentedAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftReifiedDenotationalTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftReifiableNonAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftReifiableDenotationalTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftPropositionalSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftCycLOpenExpression),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftDenotationalTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonAtomicTermAssertible),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonAtomicTermAskable),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftNonAtomicReifiedTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftIndexedTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftGenericRelationFormula),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftGAFAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftExpressionAssertible),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftExpressionAskable),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftCycLExpression),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftDenotationalTermAssertible),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftDenotationalTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftDeducedAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftConstant),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftClosedSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftClosedNonAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftClosedFormula),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftCycLClosedExpression),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftClosedDenotationalTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftClosedAtomicSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtomicTerm),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtomicSentence),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAtomicAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ftAssertedAssertion),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(vtCanonicalizerDirective),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(mtBroadMicrotheory),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(ttAtemporalNecessarilyEssentialCollectionType),iBaseKB,vStrMon).
tiny_kb(decontextualizedCollection(rtArgQuotedIsaTernaryPredicate),iBaseKB,vStrMon).
tiny_kb(not(equals(_SET,tSetOfTheSetOfFn(X,and(tSetMathematical(X),not(elementOf(X,X)))))),iBaseKB,vStrMon).
tiny_kb(not(elementOf(X,iTheEmptySet)),iBaseKB,vStrMon).
tiny_kb(not(different(OBJ,OBJ)),iBaseKB,vStrMon).
tiny_kb(not(and(resultGenlArg(FUNC,ARGNUM),arity(FUNC,ARITY),greaterThan(ARGNUM,ARITY))),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(trueSubL),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(formulaArity),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycTransformationProofRule),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycTransformationProofBindings),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycTacticID),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProofID),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreTerms),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreProofs),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreProofCount),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreProblems),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreProblemCount),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreLinks),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreLinkCount),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreInferences),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreInferenceCount),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemStoreID),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemQueryTerms),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemQuerySentence),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemProvabilityStatus),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemLinkID),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemID),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemDependentLinks),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycProblemArgumentLinks),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycInferenceRelevantProblems),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(cycInferenceAnswerLink),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(backchainForbidden),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(assertionDirection),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(admittedNAT),iBaseKB,vStrMon).
tiny_kb(backchainForbidden(admittedAllArgument),iBaseKB,vStrMon).
tiny_kb(notAssertible(unknownSentence),iBaseKB,vStrMon).
tiny_kb(notAssertible(trueSubL),iBaseKB,vStrMon).
tiny_kb(notAssertible(trueSentence),iBaseKB,vStrMon).
tiny_kb(notAssertible(termChosen),iBaseKB,vStrMon).
tiny_kb(notAssertible(sentenceImplies),iBaseKB,vStrMon).
tiny_kb(notAssertible(sentenceEquiv),iBaseKB,vStrMon).
tiny_kb(notAssertible(relationExpansion),iBaseKB,vStrMon).
tiny_kb(notAssertible(operatorFormulas),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestIsa),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestGenls),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestGenlPreds),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestGenlMt),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestDifferentIsa),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestDifferentGenls),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestCommonSpecs),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestCommonIsa),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestCommonGenls),iBaseKB,vStrMon).
tiny_kb(notAssertible(nearestCommonGenlMt),iBaseKB,vStrMon).
tiny_kb(notAssertible(natFunction),iBaseKB,vStrMon).
tiny_kb(notAssertible(natArgumentsEqual),iBaseKB,vStrMon).
tiny_kb(notAssertible(natArgument),iBaseKB,vStrMon).
tiny_kb(notAssertible(knownSentence),iBaseKB,vStrMon).
tiny_kb(notAssertible(integerBetween),iBaseKB,vStrMon).
tiny_kb(notAssertible(exactlyAssertedEL_next),iBaseKB,vStrMon).
tiny_kb(notAssertible(cycTransformationProofRule),iBaseKB,vStrMon).
tiny_kb(notAssertible(cycTransformationProofBindings),iBaseKB,vStrMon).
tiny_kb(notAssertible(constantID),iBaseKB,vStrMon).
tiny_kb(notAssertible(consistent),iBaseKB,vStrMon).
tiny_kb(notAssertible(call_u_no_bc),iBaseKB,vStrMon).
tiny_kb(notAssertible(assertedPredicateArg),iBaseKB,vStrMon).
tiny_kb(notAssertible(admittedSentence),iBaseKB,vStrMon).
tiny_kb(notAssertible(admittedNAT),iBaseKB,vStrMon).
tiny_kb(notAssertible(admittedArgument),iBaseKB,vStrMon).
tiny_kb(notAssertible(admittedAllArgument),iBaseKB,vStrMon).
tiny_kb(notAssertible(istAsserted),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(vtTruthValue),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(rtSkolemFunction),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(mtProblemSolvingCntxt),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(rtInferenceRelatedBookkeepingPredicate),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(rtExceptionPredicate),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(ftRuleAssertion),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(ftGAFAssertion),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(ftDeducedAssertion),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(vtAssertionDirection),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(ftAssertedAssertion),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(rtArgIsaBinaryPredicate),iBaseKB,vStrMon).
tiny_kb(completelyEnumerableCollection(rtArgGenlBinaryPredicate),iBaseKB,vStrMon).
tiny_kb(completelyDecidableCollection(ftIndeterminateTerm),iBaseKB,vStrMon).
tiny_kb(completelyDecidableCollection(ftHLPrototypicalTerm),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEGPRED,PRED),relationAllInstance(PRED,COL,THING),trueSentence(exists(INST,and(isa(INST,COL),t(NEGPRED,INST,THING)))))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEGPRED,PRED),isa(INST,COL),t(NEGPRED,INST,THING),relationAllInstance(PRED,COL,THING))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEG_PRED,PRED),t(NEG_PRED,ARG1,ARG2,ARG3,ARG4,ARG5),t(PRED,ARG1,ARG2,ARG3,ARG4,ARG5))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEG_PRED,PRED),t(NEG_PRED,ARG1,ARG2,ARG3,ARG4),t(PRED,ARG1,ARG2,ARG3,ARG4))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEG_PRED,PRED),t(NEG_PRED,ARG1,ARG2,ARG3),t(PRED,ARG1,ARG2,ARG3))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEG_PRED,PRED),t(NEG_PRED,ARG1,ARG2),t(PRED,ARG1,ARG2))),iBaseKB,vStrMon).
tiny_kb(not(and(negationPreds(NEG_PRED,PRED),t(NEG_PRED,ARG1),t(PRED,ARG1))),iBaseKB,vStrMon).
tiny_kb(not(and(rtIrreflexiveBinaryPredicate(PRED),t(PRED,OBJ,OBJ))),iBaseKB,vStrMon).
tiny_kb(not(and(rtIrreflexiveBinaryPredicate(PRED),equals(OBJ1,OBJ2),t(PRED,OBJ1,OBJ2))),iBaseKB,vStrMon).
tiny_kb(not(and(rtAsymmetricBinaryPredicate(PRED),rtSymmetricBinaryPredicate(PRED),t(PRED,ANYTHING1,ANYTHING2))),iBaseKB,vStrMon).
tiny_kb(not(and(rtAsymmetricBinaryPredicate(PRED),t(PRED,ARG1,ARG2),t(PRED,ARG2,ARG1))),iBaseKB,vStrMon).
tiny_kb(not(and(isa(OBJ,COL1),isa(OBJ,COL2),disjointWith(COL1,COL2))),iBaseKB,vStrMon).
tiny_kb(not(and(genlPreds(SPEC,GENL),arity(SPEC,SPEC_ARITY),different(GENL_ARITY,SPEC_ARITY),arity(GENL,GENL_ARITY))),iBaseKB,vStrMon).
tiny_kb(not(and(disjointWith(COL1,COL2),trueSentence(exists(THING,and(isa(THING,COL1),isa(THING,COL2)))))),iBaseKB,vStrMon).
tiny_kb(not(and(disjointWith(ARGTYPE1,ARGTYPE2),argIsa(PRED,ARGNUM,ARGTYPE1),argIsa(PRED,ARGNUM,ARGTYPE2))),iBaseKB,vStrMon).
tiny_kb(not(and(differentSymbols(A,B),equalSymbols(A,B))),iBaseKB,vStrMon).
tiny_kb(not(and(argIsa(PRED,2,COL1),disjointWith(COL1,COL2),isa(INST,COL2),t(PRED,_X,INST))),iBaseKB,vStrMon).
tiny_kb(not(and(argIsa(PRED,2,ARG2ISA),disjointWith(ARG2ISA,ARG2TYPE),relationExistsAll(PRED,ARG1TYPE,ARG2TYPE))),iBaseKB,vStrMon).
tiny_kb(not(and(argIsa(PRED,2,ARG2ISA),disjointWith(ARG2ISA,ARG2TYPE),relationAllExists(PRED,ARG1TYPE,ARG2TYPE))),iBaseKB,vStrMon).
tiny_kb(not(and(argGenl(PRED,2,ARG2TYPE),disjointWith(ARG2TYPE,GROUPMEMBERTYPE),relationAllInstance(PRED,GROUPTYPE,GROUPMEMBERTYPE))),iBaseKB,vStrMon).
tiny_kb(not(and(argIsa(PRED,1,ARG1ISA),disjointWith(ARG1ISA,ARG1TYPE),relationAllExists(PRED,ARG1TYPE,ARG2TYPE))),iBaseKB,vStrMon).
tiny_kb(interArgResultIsa(iFunctionToArgFn,2,rtTernaryPredicate,rtBinaryFunction),iBaseKB,vStrDef).
tiny_kb(interArgResultIsa(iFunctionToArgFn,2,rtBinaryPredicate,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(xor,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(xor,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(not,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(implies,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(implies,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(equiv,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(equiv,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argIsa(siblingDisjointExceptions,2,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(siblingDisjointExceptions,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,2,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,2,tIndividual),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,1,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,1,tIndividual),iBaseKB,vStrDef).
tiny_kb(argIsa(resultIsa,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(resultGenl,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(numericallyEquals,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(numericallyEquals,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(isa,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(isa,1,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThanOrEqualTo,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThanOrEqualTo,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThan,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThan,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(genls,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(genls,1,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(genlPreds,2,tPred),iBaseKB,vStrDef).
tiny_kb(argIsa(genlPreds,1,tPred),iBaseKB,vStrDef).
tiny_kb(argIsa(genlMt,2,tMicrotheory),iBaseKB,vStrDef).
tiny_kb(argIsa(genlMt,1,tMicrotheory),iBaseKB,vStrDef).
tiny_kb(argIsa(vPlusAllFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vPlusAllFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(vMinimumFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vMinimumFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(vMaximumFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vMaximumFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasUri,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasUri,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasScalability,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasScalability,1,larkcScalability),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasEndpoint,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasEndpoint,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasCostPerInvocation,2,larkcEuro),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasCostPerInvocation,1,larkcCost),iBaseKB,vStrDef).
tiny_kb(argIsa(vAverageFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vAverageFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(distributesOutOfArg(and,holdsIn,2),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg1Isa,rtArgTypeBinaryPredicate,tRelation),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg1Isa,rtArgTypeTernaryPredicate,tRelation),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg2Isa,rtArgGenlBinaryPredicate,tCol),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg2Isa,rtArgIsaBinaryPredicate,tCol),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg2Isa,rtArgTypeTernaryPredicate,ftNonNegativeInteger),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg3Isa,rtArgGenlTernaryPredicate,tCol),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arg3Isa,rtArgIsaTernaryPredicate,tCol),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arityMax,ttUnitOfMeasure,2),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(arityMin,ttUnitOfMeasure,1),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(assertionDirection,ftGAFAssertion,vForwardAssertionDirection),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(assertionDirection,ftRuleAssertion,vBackwardAssertionDirection),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(definingMt,tMicrotheory,iBaseKB),iBaseKB,vStrDef).
tiny_kb(relationAllInstance(genlMt,tMicrotheory,iBaseKB),iBaseKB,vStrDef).
tiny_kb(relationInstanceAll(subsetOf,iTheEmptySet,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(transitiveViaArg(argAndRestGenl,genls,3),iBaseKB,vStrDef).
tiny_kb(transitiveViaArg(genlInverse,genlPreds,2),iBaseKB,vStrDef).
tiny_kb(transitiveViaArgInverse(genlInverse,genlPreds,1),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(termOfUnit),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(termDependsOn),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(skolem),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(ruleAfterRemoving),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(ruleAfterAdding),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(evaluationDefn),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(defnSufficient),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(defnNecessary),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(defnIff),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(afterRemoving),iBaseKB,vStrDef).
tiny_kb(rtInferenceRelatedBookkeepingPredicate(afterAdding),iBaseKB,vStrDef).
tiny_kb(tRuleTemplate('NART'([iCollectionRuleTemplateFn,mtHypotheticalContext])),iBaseKB,vStrDef).
tiny_kb(tRuleTemplate('NART'([iCollectionRuleTemplateFn,rtArgIsaPredicate])),iBaseKB,vStrDef).
tiny_kb(wslClassificationRoot(larkcPlugin),iBaseKB,vStrDef).
tiny_kb(mtBroadMicrotheory(iBaseKB),iBaseKB,vStrDef).
tiny_kb(genls(larkcVariableBinding,larkcInformationSet),iBaseKB,vStrDef).
tiny_kb(genls(larkcTriplePatternQuery,larkcQuery),iBaseKB,vStrDef).
tiny_kb(genls(larkcSPARQLQuery,larkcQuery),iBaseKB,vStrDef).
tiny_kb(genls(larkcSetOfStatements,larkcInformationSet),iBaseKB,vStrDef).
tiny_kb(genls(larkcSelecter,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcScalability,wslNonFunctionalParameter),iBaseKB,vStrDef).
tiny_kb(genls(larkcReasoner,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcRdfGraph,larkcSetOfStatements),iBaseKB,vStrDef).
tiny_kb(genls(larkcQueryTransformer,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcQuery,larkcResource),iBaseKB,vStrDef).
tiny_kb(genls(larkcNaturalLanguageDocument,larkcInformationSet),iBaseKB,vStrDef).
tiny_kb(genls(larkcLabelledGroupOfStatements,larkcSetOfStatements),iBaseKB,vStrDef).
tiny_kb(genls(larkcKeywordQuery,larkcQuery),iBaseKB,vStrDef).
tiny_kb(genls(larkcInformationSetTransformer,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcInformationSet,larkcResource),iBaseKB,vStrDef).
tiny_kb(genls(larkcIdentifier,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcGateTransformer,larkcInformationSetTransformer),iBaseKB,vStrDef).
tiny_kb(genls(larkcDecider,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(genls(larkcDataSet,larkcSetOfStatements),iBaseKB,vStrDef).
tiny_kb(genls(larkcCycSelecter,larkcSelecter),iBaseKB,vStrDef).
tiny_kb(genls(larkcCycReasoner,larkcReasoner),iBaseKB,vStrDef).
tiny_kb(genls(larkcCycGateDecider,larkcDecider),iBaseKB,vStrDef).
tiny_kb(genls(larkcCost,wslNonFunctionalParameter),iBaseKB,vStrDef).
tiny_kb(genls(larkcBooleanInformationSet,larkcInformationSet),iBaseKB,vStrDef).
tiny_kb(genls(larkcArticleIdentifier,larkcIdentifier),iBaseKB,vStrDef).
tiny_kb(argsQuotedIsa(or,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argsQuotedIsa(and,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argFormat(different,6,vSetTheFormat),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(xor,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(implies,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(equiv,2,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argIsa(siblingDisjointExceptions,2,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,2,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,2,tIndividual),iBaseKB,vStrDef).
tiny_kb(argIsa(resultIsa,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(resultGenl,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(numericallyEquals,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(isa,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThanOrEqualTo,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThan,2,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(genls,2,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(genlPreds,2,tPred),iBaseKB,vStrDef).
tiny_kb(argIsa(genlMt,2,tMicrotheory),iBaseKB,vStrDef).
tiny_kb(argIsa(vPlusAllFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vMinimumFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(vMaximumFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasUri,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasScalability,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasEndpoint,2,ftString),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasCostPerInvocation,2,larkcEuro),iBaseKB,vStrDef).
tiny_kb(argIsa(vAverageFn,2,rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcPluginByDataConnectsTo,2,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcHasOutputType,2,larkcResource),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcHasInputType,2,larkcResource),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(xor,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(not,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(implies,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argQuotedIsa(equiv,1,ftSentenceAssertible),iBaseKB,vStrDef).
tiny_kb(argIsa(siblingDisjointExceptions,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,1,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(sentenceEquiv,1,tIndividual),iBaseKB,vStrDef).
tiny_kb(argIsa(resultIsa,1,tRelation),iBaseKB,vStrDef).
tiny_kb(argIsa(resultGenl,1,tRelation),iBaseKB,vStrDef).
tiny_kb(argIsa(numericallyEquals,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(isa,1,tThing),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThanOrEqualTo,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(greaterThan,1,vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(argIsa(genls,1,tCol),iBaseKB,vStrDef).
tiny_kb(argIsa(genlPreds,1,tPred),iBaseKB,vStrDef).
tiny_kb(argIsa(genlMt,1,tMicrotheory),iBaseKB,vStrDef).
tiny_kb(argIsa(vPlusAllFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(vMinimumFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(vMaximumFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasUri,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasScalability,1,larkcScalability),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasEndpoint,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argIsa(larkcHasCostPerInvocation,1,larkcCost),iBaseKB,vStrDef).
tiny_kb(argIsa(vAverageFn,1,ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcPluginByDataConnectsTo,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcHasOutputType,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(argGenl(larkcHasInputType,1,larkcPlugin),iBaseKB,vStrDef).
tiny_kb(definingMt(termOfUnit,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(termDependsOn,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(myCreationPurpose,iBookkeepingMt),iBaseKB,vStrDef).
tiny_kb(definingMt(evaluationDefn,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(defnSufficient,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(defnNecessary,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(defnIff,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(afterRemoving,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(afterAdding,iBaseKB),iBaseKB,vStrDef).
tiny_kb(definingMt(tHumanCyclist,iBaseKB),iBaseKB,vStrDef).
tiny_kb(implies_bc(quotedIsa(X,COL),isa(xQuoteFn(xEscapeQuoteFn(X)),COL)),iBaseKB,vStrDef).
tiny_kb(equiv(arity(REL,3),rtTernaryRelation(REL)),iBaseKB,vStrDef).
tiny_kb(expansion(genls,implies(':ARG1'(OBJ),':ARG2'(OBJ))),iBaseKB,vStrDef).
tiny_kb(expansion(requiredArg2Pred,implies(and(rtBinaryPredicate(':ARG2'),':ARG1'(INS_1)),exists(INS,':ARG2'(INS,INS_1)))),iBaseKB,vStrDef).
tiny_kb(expansion(requiredArg1Pred,implies(and(rtBinaryPredicate(':ARG2'),':ARG1'(INS_1)),exists(INS,':ARG2'(INS_1,INS)))),iBaseKB,vStrDef).
tiny_kb(expansion(relationInstanceExists,exists(ARG,and(':ARG3'(ARG),':ARG1'(':ARG2',ARG)))),iBaseKB,vStrDef).
tiny_kb(expansion(relationExistsMinAll,implies(':ARG3'(ARG2),thereExistAtLeast(':ARG4',ARG,and(':ARG2'(ARG),':ARG1'(ARG,ARG2))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationExistsMaxAll,implies(':ARG3'(ARG2),thereExistAtMost(':ARG4',ARG,and(':ARG2'(ARG),':ARG1'(ARG,ARG2))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationExistsInstance,exists(OBJ,and(':ARG2'(OBJ),':ARG1'(OBJ,':ARG3')))),iBaseKB,vStrDef).
tiny_kb(expansion(relationExistsCountAll,implies(':ARG3'(ARG2),thereExistExactly(':ARG4',ARG1,and(':ARG2'(ARG1),':ARG1'(ARG1,ARG2))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationAllExistsMin,implies(':ARG2'(ARG1),thereExistAtLeast(':ARG4',ARG,and(':ARG3'(ARG),':ARG1'(ARG1,ARG))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationAllExistsMax,implies(':ARG2'(ARG1),thereExistAtMost(':ARG4',ARG,and(':ARG3'(ARG),':ARG1'(ARG1,ARG))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationAllExistsCount,implies(':ARG2'(TERM),thereExistExactly(':ARG4',OTHER,and(':ARG3'(OTHER),':ARG1'(TERM,OTHER))))),iBaseKB,vStrDef).
tiny_kb(expansion(relationAll,implies(':ARG2'(OBJ),':ARG1'(OBJ))),iBaseKB,vStrDef).
tiny_kb(expansion(negationInverse,not(and(':ARG1'(ARG1,ARG2),':ARG2'(ARG2,ARG1)))),iBaseKB,vStrDef).
tiny_kb(expansion(genlInverse,implies(':ARG1'(ARG1,ARG2),':ARG2'(ARG2,ARG1))),iBaseKB,vStrDef).
tiny_kb(expansion(equiv,and(implies(':ARG1',':ARG2'),implies(':ARG2',':ARG1'))),iBaseKB,vStrDef).
tiny_kb(expansion(disjointWith,not(and(':ARG1'(OBJ),':ARG2'(OBJ)))),iBaseKB,vStrDef).
tiny_kb(expansion(interArgGenl1_2,implies(and(genls(INDEP_SPEC,':ARG2'),':ARG1'(INDEP_SPEC,DEP_SPEC)),genls(DEP_SPEC,':ARG3'))),iBaseKB,vStrDef).
tiny_kb(expansion(implies,or(':ARG2',not(':ARG1'))),iBaseKB,vStrDef).
tiny_kb(expansion(genlPreds,implies(t([':ARG1','?ARGS']),t([':ARG2','?ARGS']))),iBaseKB,vStrDef).
tiny_kb(expansion(quotedIsa,':ARG2'(xQuasiQuoteFn(':ARG1'))),iBaseKB,vStrDef).
tiny_kb(expansion(negationPreds,not(and(t([':ARG1','?ARGS']),t([':ARG2','?ARGS'])))),iBaseKB,vStrDef).
tiny_kb(expansion(xor,or(and(':ARG1',not(':ARG2')),and(':ARG2',not(':ARG1')))),iBaseKB,vStrDef).
tiny_kb(equals(NUM,vUnityFn(NUM)),iBaseKB,vStrDef).
tiny_kb(implies(tRuleTemplate(TEMPLATE),ruleTemplateDirection(TEMPLATE,vBackwardAssertionDirection)),iBaseKB,vStrDef).
tiny_kb(implies(argIsa(PRED,6,TYPE),resultIsa(iFunctionToArgFn(6,PRED),TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(argIsa(PRED,5,TYPE),resultIsa(iFunctionToArgFn(5,PRED),TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(argIsa(PRED,4,TYPE),resultIsa(iFunctionToArgFn(4,PRED),TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(argIsa(PRED,3,TYPE),resultIsa(iFunctionToArgFn(3,PRED),TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(argIsa(PRED,1,TYPE),resultIsa(iFunctionToArgFn(1,PRED),TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(afterRemoving(PRED,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE')),afterAdding(PRED,uSubLQuoteFn('ADD-TVA-CACHE-VALUE'))),iBaseKB,vStrDef).
tiny_kb(implies(afterRemoving(PRED,uSubLQuoteFn('REMOVE-TVA-CACHE-KEY')),afterAdding(PRED,uSubLQuoteFn('ADD-TVA-CACHE-KEY'))),iBaseKB,vStrDef).
tiny_kb(implies(afterAdding(PRED,uSubLQuoteFn('ADD-TVA-CACHE-VALUE')),afterRemoving(PRED,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE'))),iBaseKB,vStrDef).
tiny_kb(implies(afterAdding(PRED,uSubLQuoteFn('ADD-TVA-CACHE-KEY')),afterRemoving(PRED,uSubLQuoteFn('REMOVE-TVA-CACHE-KEY'))),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,5,IND_COL,4,DEP_COL),interArgIsa(CONSTRAINED_PRED,5,IND_COL,4,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,5,IND_COL,3,DEP_COL),interArgIsa(CONSTRAINED_PRED,5,IND_COL,3,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,5,IND_COL,2,DEP_COL),interArgIsa(CONSTRAINED_PRED,5,IND_COL,2,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,5,IND_COL,1,DEP_COL),interArgIsa(CONSTRAINED_PRED,5,IND_COL,1,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,4,IND_COL,5,DEP_COL),interArgIsa(CONSTRAINED_PRED,4,IND_COL,5,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,4,IND_COL,3,DEP_COL),interArgIsa(CONSTRAINED_PRED,4,IND_COL,3,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,4,IND_COL,2,DEP_COL),interArgIsa(CONSTRAINED_PRED,4,IND_COL,2,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,4,IND_COL,1,DEP_COL),interArgIsa(CONSTRAINED_PRED,4,IND_COL,1,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,3,IND_COL,5,DEP_COL),interArgIsa(CONSTRAINED_PRED,3,IND_COL,5,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,3,IND_COL,4,DEP_COL),interArgIsa(CONSTRAINED_PRED,3,IND_COL,4,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,3,IND_COL,2,DEP_COL),interArgIsa(CONSTRAINED_PRED,3,IND_COL,2,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,3,IND_COL,1,DEP_COL),interArgIsa(CONSTRAINED_PRED,3,IND_COL,1,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,2,IND_COL,5,DEP_COL),interArgIsa(CONSTRAINED_PRED,2,IND_COL,5,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,2,IND_COL,4,DEP_COL),interArgIsa(CONSTRAINED_PRED,2,IND_COL,4,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,2,IND_COL,3,DEP_COL),interArgIsa(CONSTRAINED_PRED,2,IND_COL,3,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,2,IND_COL,1,DEP_COL),interArgIsa(CONSTRAINED_PRED,2,IND_COL,1,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,1,IND_COL,5,DEP_COL),interArgIsa(CONSTRAINED_PRED,1,IND_COL,5,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,1,IND_COL,4,DEP_COL),interArgIsa(CONSTRAINED_PRED,1,IND_COL,4,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,1,IND_COL,3,DEP_COL),interArgIsa(CONSTRAINED_PRED,1,IND_COL,3,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(interArgIsa(CONSTRAINED_PRED,1,IND_COL,2,DEP_COL),interArgIsa(CONSTRAINED_PRED,1,IND_COL,2,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgIsaPredicate(PRED),argIsa(PRED,1,tRelation)),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgIsaPredicate(PRED),afterRemoving(PRED,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING'))),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgIsaPredicate(PRED),afterAdding(PRED,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING'))),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgFormatPredicate(PRED),argIsa(PRED,1,tRelation)),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgFormatPredicate(PRED),afterRemoving(PRED,uSubLQuoteFn('INTER-ARG-FORMAT-AFTER-REMOVING'))),iBaseKB,vStrDef).
tiny_kb(implies(rtInterArgFormatPredicate(PRED),afterAdding(PRED,uSubLQuoteFn('INTER-ARG-FORMAT-AFTER-ADDING'))),iBaseKB,vStrDef).
tiny_kb(implies(rtBookkeepingPredicate(PRED),minimizeExtent(PRED)),iBaseKB,vStrDef).
tiny_kb(implies(ttUnitOfMeasure(MEASURE_FN),resultIsa(MEASURE_FN,vtScalarInterval)),iBaseKB,vStrDef).
tiny_kb(implies(rtIndeterminateTermDenotingFunction(FUNC),resultQuotedIsa(FUNC,ftIndeterminateTerm)),iBaseKB,vStrDef).
tiny_kb(implies(and(natFunction(NAT,FUNC),isa(TERM,INDEP_COL),natArgument(NAT,ARG,TERM),interArgResultIsa(FUNC,ARG,INDEP_COL,DEP_COL)),isa(NAT,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(genlPreds(SPEC_PRED,genls),afterRemoving(SPEC_PRED,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE'))),iBaseKB,vStrDef).
tiny_kb(implies(genlPreds(EQUALITY_PRED,equals),afterRemoving(EQUALITY_PRED,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE'))),iBaseKB,vStrDef).
tiny_kb(implies(genlPreds(EQUALITY_PRED,equals),afterAdding(EQUALITY_PRED,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE'))),iBaseKB,vStrDef).
tiny_kb(implies(genlInverse(SPEC_INVERSE,genls),afterRemoving(SPEC_INVERSE,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE'))),iBaseKB,vStrDef).
tiny_kb(implies(and(resultIsa(F,COL),termOfUnit(U,F)),isa(U,COL)),iBaseKB,vStrDef).
tiny_kb(resultQuotedIsa(uRelationInstanceExistsFn,ftIndeterminateTerm),iBaseKB,vStrDef).
tiny_kb(resultQuotedIsa(uRelationExistsInstanceFn,ftIndeterminateTerm),iBaseKB,vStrDef).
tiny_kb(resultQuotedIsa(uRelationExistsAllFn,ftIndeterminateTerm),iBaseKB,vStrDef).
tiny_kb(resultQuotedIsa(uRelationAllExistsFn,ftIndeterminateTerm),iBaseKB,vStrDef).
tiny_kb(sentenceDesignationArgnum(ist,2),iBaseKB,vStrDef).
tiny_kb(sentenceDesignationArgnum(xTLAssertionFn,2),iBaseKB,vStrDef).
tiny_kb(sentenceDesignationArgnum(istAsserted,2),iBaseKB,vStrDef).
tiny_kb(scopingArg(exists,1),iBaseKB,vStrDef).
tiny_kb(scopingArg(thereExistExactly,2),iBaseKB,vStrDef).
tiny_kb(scopingArg(thereExistAtMost,2),iBaseKB,vStrDef).
tiny_kb(scopingArg(thereExistAtLeast,2),iBaseKB,vStrDef).
tiny_kb(scopingArg(all,1),iBaseKB,vStrDef).
tiny_kb(scopingArg(tSetOfTheSetOfFn,1),iBaseKB,vStrDef).
tiny_kb(scopingArg(tColOfTheCollectionOfFn,1),iBaseKB,vStrDef).
tiny_kb(scopingArg(iKappaFn,1),iBaseKB,vStrDef).
tiny_kb(afterRemoving(transitiveViaArgInverse,uSubLQuoteFn('REMOVE-TRANSITIVE-VIA-ARG-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(transitiveViaArgInverse,uSubLQuoteFn('CLEAR-CACHED-SOME-TVA-CHECKS')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(transitiveViaArg,uSubLQuoteFn('REMOVE-TRANSITIVE-VIA-ARG')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(transitiveViaArg,uSubLQuoteFn('CLEAR-CACHED-TVA-CHECKS')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(termDependsOn,uSubLQuoteFn('REMOVE-DEPENDENT-TERM')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(substring,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(substring,uSubLQuoteFn('REMOVE-TVA-CACHE-KEY')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(rewriteOf,uSubLQuoteFn('DECACHE-SOME-SOURCE-REWRITE-OF-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(rewriteOf,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(rewriteOf,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulatorRuleProperties,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulatorRule,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulatorEquiv,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulatorEquals,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulationPrecondition,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(reformulationDirectionInMode,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(prettyString,uSubLQuoteFn('REMOVE-SEMANTIC-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(prettyString,uSubLQuoteFn('REMOVE-PROPER-NAME-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(negationPreds,uSubLQuoteFn('NEGATION-PREDICATE-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(negationInverse,uSubLQuoteFn('REMOVE-NEGATION-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(nearestGenls,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(natFunction,uSubLQuoteFn('REMOVE-DEPENDENT-TERM')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(indexicalReferent,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(genls,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(genlPreds,uSubLQuoteFn('REMOVE-GENL-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(genlInverse,uSubLQuoteFn('REMOVE-GENL-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(expansion,uSubLQuoteFn('REMOVE-GEN-TEMPLATE-EXPANSION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(expansion,uSubLQuoteFn('REMOVE-FROM-CONTRACTION-HT')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(expansion,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(evaluationDefn,uSubLQuoteFn('DECACHE-LISP-DEFUN')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(equalSymbols,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(equals,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(definingMt,uSubLQuoteFn('REMOVE-DEPENDENT-TERM')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(defaultReformulatorModePrecedence,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(defaultReformulationDirectionInModeForPred,uSubLQuoteFn('CYC-REMOVE-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(coExtensional,uSubLQuoteFn('REMOVE-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(arityMin,uSubLQuoteFn('REMOVE-MAX-ARITY')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(arityMax,uSubLQuoteFn('REMOVE-MAX-ARITY')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(prettyStringCanonical,uSubLQuoteFn('REMOVE-SEMANTIC-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(prettyStringCanonical,uSubLQuoteFn('REMOVE-PROPER-NAME-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa5_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa5_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa5_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa5_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa4_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa4_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa4_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa4_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa3_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa3_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa3_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa3_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa2_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa2_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa2_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa2_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa1_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa1_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa1_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgIsa1_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(interArgFormat1_2,uSubLQuoteFn('INTER-ARG-FORMAT-AFTER-REMOVING')),iBaseKB,vStrDef).
tiny_kb(afterRemoving(equalStringsCaseinsensitive,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(transitiveViaArgInverse,uSubLQuoteFn('CLEAR-CACHED-SOME-TVA-CHECKS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(transitiveViaArgInverse,uSubLQuoteFn('ADD-TRANSITIVE-VIA-ARG-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(transitiveViaArg,uSubLQuoteFn('CLEAR-CACHED-TVA-CHECKS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(transitiveViaArg,uSubLQuoteFn('ADD-TRANSITIVE-VIA-ARG')),iBaseKB,vStrDef).
tiny_kb(afterAdding(substring,uSubLQuoteFn('ADD-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(substring,uSubLQuoteFn('ADD-TVA-CACHE-KEY')),iBaseKB,vStrDef).
tiny_kb(afterAdding(rewriteOf,uSubLQuoteFn('REWRITE-OF-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(rewriteOf,uSubLQuoteFn('DECACHE-SOME-SOURCE-REWRITE-OF-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(rewriteOf,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(rewriteOf,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulatorRuleProperties,uSubLQuoteFn('PROPAGATE-INVERSE-TO-ISA')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulatorRuleProperties,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulatorRule,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulatorEquiv,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulatorEquals,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulationPrecondition,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(reformulationDirectionInMode,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(prettyString,uSubLQuoteFn('ADD-SEMANTIC-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(prettyString,uSubLQuoteFn('ADD-PROPER-NAME-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(negationPreds,uSubLQuoteFn('NEGATION-PREDICATE-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(negationInverse,uSubLQuoteFn('ADD-NEGATION-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(nearestIsa,uSubLQuoteFn('PROPAGATE-TO-ISA')),iBaseKB,vStrDef).
tiny_kb(afterAdding(nearestGenls,uSubLQuoteFn('PROPAGATE-TO-GENLS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(nearestGenls,uSubLQuoteFn('ADD-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(nearestGenlPreds,uSubLQuoteFn('PROPAGATE-TO-GENLPREDS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(nearestGenlMt,uSubLQuoteFn('PROPAGATE-TO-GENLMT')),iBaseKB,vStrDef).
tiny_kb(afterAdding(ist,uSubLQuoteFn('ADD-IST')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(indexicalReferent,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(genls,uSubLQuoteFn('ADD-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(genlPreds,uSubLQuoteFn('ADD-GENL-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(genlInverse,uSubLQuoteFn('ADD-GENL-INVERSE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(genKeyword,uSubLQuoteFn('ADD-GEN-KEYWORD')),iBaseKB,vStrDef).
tiny_kb(afterAdding(expansion,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(expansion,uSubLQuoteFn('ADD-TO-CONTRACTION-HT')),iBaseKB,vStrDef).
tiny_kb(afterAdding(expansion,uSubLQuoteFn('ADD-GEN-TEMPLATE-EXPANSION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(evaluationDefn,uSubLQuoteFn('DECACHE-LISP-DEFUN')),iBaseKB,vStrDef).
tiny_kb(afterAdding(equalSymbols,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(equals,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(elInverse,uSubLQuoteFn('PROPAGATE-TO-GENLINVERSE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(elInverse,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLINVERSE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(defaultReformulatorModePrecedence,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(defaultReformulationDirectionInModeForPred,uSubLQuoteFn('CYC-ADD-REFORMULATION-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(coExtensional,uSubLQuoteFn('PROPAGATE-TO-GENLS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(coExtensional,uSubLQuoteFn('PROPAGATE-INVERSE-TO-GENLS')),iBaseKB,vStrDef).
tiny_kb(afterAdding(coExtensional,uSubLQuoteFn('ADD-TVA-CACHE-VALUE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(arityMin,uSubLQuoteFn('ADD-MAX-ARITY')),iBaseKB,vStrDef).
tiny_kb(afterAdding(arityMax,uSubLQuoteFn('ADD-MAX-ARITY')),iBaseKB,vStrDef).
tiny_kb(afterAdding(prettyStringCanonical,uSubLQuoteFn('ADD-SEMANTIC-ASSERTION')),iBaseKB,vStrDef).
tiny_kb(afterAdding(prettyStringCanonical,uSubLQuoteFn('ADD-PROPER-NAME-PREDICATE')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa5_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa5_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa5_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa5_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa4_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa4_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa4_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa4_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa3_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa3_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa3_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa3_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa2_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa2_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa2_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa2_1,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa1_5,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa1_4,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa1_3,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgIsa1_2,uSubLQuoteFn('INTER-ARG-ISA-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(interArgFormat1_2,uSubLQuoteFn('INTER-ARG-FORMAT-AFTER-ADDING')),iBaseKB,vStrDef).
tiny_kb(afterAdding(equalStringsCaseinsensitive,uSubLQuoteFn('DECACHE-SOME-EQUALITY-ASSERTIONS-SOMEWHERE')),iBaseKB,vStrDef).
tiny_kb(larkcPluginByDataConnectsTo(larkcGateTransformer,larkcCycSelecter),iBaseKB,vStrDef).
tiny_kb(larkcPluginByDataConnectsTo(larkcGateTransformer,larkcCycReasoner),iBaseKB,vStrDef).
tiny_kb(larkcPluginByDataConnectsTo(larkcCycSelecter,larkcCycSelecter),iBaseKB,vStrDef).
tiny_kb(larkcPluginByDataConnectsTo(larkcCycSelecter,larkcCycReasoner),iBaseKB,vStrDef).
tiny_kb(larkcPluginByDataConnectsTo(larkcArticleIdentifier,larkcGateTransformer),iBaseKB,vStrDef).
tiny_kb(larkcHasOutputType(larkcGateTransformer,larkcRdfGraph),iBaseKB,vStrDef).
tiny_kb(larkcHasOutputType(larkcCycSelecter,larkcRdfGraph),iBaseKB,vStrDef).
tiny_kb(larkcHasOutputType(larkcCycReasoner,larkcVariableBinding),iBaseKB,vStrDef).
tiny_kb(larkcHasOutputType(larkcArticleIdentifier,larkcNaturalLanguageDocument),iBaseKB,vStrDef).
tiny_kb(larkcHasInputType(larkcGateTransformer,larkcNaturalLanguageDocument),iBaseKB,vStrDef).
tiny_kb(larkcHasInputType(larkcCycSelecter,larkcSetOfStatements),iBaseKB,vStrDef).
tiny_kb(larkcHasInputType(larkcCycReasoner,larkcSetOfStatements),iBaseKB,vStrDef).
tiny_kb(larkcHasInputType(larkcArticleIdentifier,larkcSPARQLQuery),iBaseKB,vStrDef).
tiny_kb(predicateConventionMt(termOfUnit,iBaseKB),iBaseKB,vStrDef).
tiny_kb(predicateConventionMt(notAssertibleMt,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(predicateConventionMt(nearestGenlMt,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(predicateConventionMt(decontextualizedCollection,iBaseKB),iBaseKB,vStrDef).
tiny_kb(microtheoryDesignationArgnum(ist,1),iBaseKB,vStrDef).
tiny_kb(microtheoryDesignationArgnum(xTLAssertionFn,1),iBaseKB,vStrDef).
tiny_kb(microtheoryDesignationArgnum(istAsserted,1),iBaseKB,vStrDef).
tiny_kb(expansionDefn(xTLVariableFn,uSubLQuoteFn('TL-VAR-TO-EL')),iBaseKB,vStrDef).
tiny_kb(expansionDefn(xTLReifiedNatFn,uSubLQuoteFn('TL-FUNCTION-TERM-TO-EL')),iBaseKB,vStrDef).
tiny_kb(expansionDefn(xTLAssertionFn,uSubLQuoteFn('TL-ASSERTION-TERM-TO-EL')),iBaseKB,vStrDef).
tiny_kb(conceptuallyRelated(vtHLTruthValue,vtTruthValue),iBaseKB,vStrDef).
tiny_kb(commutativeInArgsAndRest(commutativeInArgsAndRest,2),iBaseKB,vStrDef).
tiny_kb(commutativeInArgsAndRest(commutativeInArgs,2),iBaseKB,vStrDef).
tiny_kb(comment(vUnknownHLTruthValue,"An instance of CycHLTruthValue. Unknown-HLTruthValue is the attribute of being neither known to be true nor known to be false."),iBaseKB,vStrDef).
tiny_kb(comment(vTrue,"An instance of TruthValue (q.v.).  True is the logical notion of truth.  That is, the term 'True' is used as a sentential constant of CycL that is true under every model theoretic interpretation.  For example, (booleanResult T/F True) means that the result obtained from the true-or-false test T/F is True.  Cf. False."),iBaseKB,vStrDef).
tiny_kb(comment(iTheUser,"TheUser denotes the `current user' of an individual, running Cyc image.  Note that at any moment there may actually be many current users of an image, communicating with it through various sorts of API: HTML-based browser, telnet API connection, etc. TheUser serves as a placeholder allowing Cyc to keep track of relevant characteristics (including authorization, sophistication level) of each distinct user."),iBaseKB,vStrDef).
tiny_kb(comment(tColOfTheCollectionOfFn,"A collection denoting function that takes a CycL variable and an open formula with exactly one free variable to the collecion of things satisfying that formula."),iBaseKB,vStrDef).
tiny_kb(comment(xTemporaryEnglishParaphraseMt,"This is a temporary MT for holding paraphrase assertions prior to review, after which time they will be moved to EnglishParaphraseMt"),iBaseKB,vStrDef).
tiny_kb(comment(vSingleEntry,"An instance of Format (q.v.) that can be specified to hold of a given predicate with respect to a given argument-place (see argFormat).  (argFormat PRED N SingleEntry) means that, for any particular way of fixing the other arguments to PRED besides the Nth, there is at most one thing such that, if taken as the Nth argument, PRED holds of those arguments.  That is, if the sequences <... ARGN ...> and <... ARGN-PRIME ...> differ at most in their Nth items and both (PRED ... ARGN ...) and (PRED ... ARGN-PRIME ...) hold, then ARGN = ARGN-PRIME (see equals).  For example, the format of biologicalMother's second argument-place is single-entry, since an animal can only have one biological mother.  A predicate with a single-entry format argument-place is thus a StrictlyFunctionalPredicate (q.v.) that is strictly functional with respect to that argument-place (see strictlyFunctionalInArgs).  Contrast with SetTheFormat."),iBaseKB,vStrDef).
tiny_kb(comment(vSetTheFormat,"An instance of Format (q.v.) that can be specified to hold of a given predicate with respect to a given argument-place (see argFormat).  (argFormat PRED N SetTheFormat) means that, for any particular way of fixing the other arguments to PRED besides the Nth, there might be any number (including zero) of things such that, if taken as the Nth argument, PRED holds of those arguments.  For example, the format of biologicalMother's first argument-place is SetTheFormat, since a female animal might have any number of offspring.  Unlike the other reified instances of Format, SetTheFormat actually places no restriction at all on what PRED might or might not hold of with respect to the relevant argument-place.  But one should not infer from this that entry-format assertions using SetTheFormat are pointless; for they forestall duplication of effort by serving notice that the entry-format of a given argument-place has previously been considered and SetTheFormat was deemed the appropriate format.  SetTheFormat is the most commonly-encountered format in the Cyc Knowledge Base.  Contrast with SingleEntry."),iBaseKB,vStrDef).
tiny_kb(comment(vMonotonicallyTrue,"An instance of CycHLTruthValue.  MonotonicallyTrue is the attribute of being indefeasibly true."),iBaseKB,vStrDef).
tiny_kb(comment(vMonotonicallyFalse,"An instance of CycHLTruthValue.  MonotonicallyFalse is the attribute of being indefeasibly false."),iBaseKB,vStrDef).
tiny_kb(comment(vIntervalEntry,"An instance of Format (q.v.) that can be specified to hold of a given predicate with respect to a given argument-place (see argFormat), where the argument-place in question is one constrained (via argIsa) to instances of ScalarInterval.   (argFormat PRED N IntervalEntry) means that, for any particular way of fixing the other arguments to PRED besides the Nth, there may be more than one instance of ScalarInterval such that, if taken as the Nth argument, PRED holds of those arguments.  However, if there is more than one instance of ScalarInterval taken as the Nth argument in such a situation, it must be the case that each of the instances of ScalarInterval intersect one another (see quantityIntersects).  That is, if the sequences <... ARGN-1 ...>, <... ARGN-2 ...>, ..., <... ARGN-M ...> differ at most in their Nth items and each of (PRED ... ARGN-1 ...), (PRED ... ARGN-2 ...), ..., (PRED ... ARGN-M ...) holds, then for any distinct ARGN-K and ARGN-L, where K and L are greater than or equal to 1, and less than or equal to M, (quantityIntersects ARGN-K ARGN-L). For example, the format of volumeOfObject's second argument-place is IntervalEntry."),iBaseKB,vStrDef).
tiny_kb(comment(vGuest,"An instance of HumanCyclist.  A Cyc user logged in                            \nas `Guest' will be able to browse the Cyc knowledge base to some extent, but will not have full rights to inspect and modify it."),iBaseKB,vStrDef).
tiny_kb(comment(vFalse,"An instance of TruthValue (q.v.).  False is the logical notion of falsehood.  That is, the term 'False' is used as a sentential constant of CycL that is false under every model theoretic interpretation.  For example, (booleanResult T/F False) means that the result obtained from the true-or-false test T/F is False.  Cf. True."),iBaseKB,vStrDef).
tiny_kb(comment(iEnglishParaphraseMt,"An instance of both ParaphraseDataMicrotheory and GeneralMicrotheory.  EnglishParaphraseMt is the default context used for generating English paraphrases for CycL expressions.  Many of the assertions required for English paraphrase generation, including those with the predicates genFormat and genPhrase (qq.v.), can be found in this context."),iBaseKB,vStrDef).
tiny_kb(comment(vDefaultTrue,"An instance of CycHLTruthValue.  DefaultTrue is the attribute of being assumed true unless otherwise known to be false."),iBaseKB,vStrDef).
tiny_kb(comment(vDefaultFalse,"An instance of CycHLTruthValue.  DefaultFalse is the attribute of being assumed false unless otherwise known to be true."),iBaseKB,vStrDef).
tiny_kb(comment(iBookkeepingMt,"A Microtheory for stating basic bookkeeping information regarding the Cyc Knowledge Base, such as assertions using myCreator or myCreationTime."),iBaseKB,vStrDef).
tiny_kb(comment(iBaseKB,"BaseKB is the most general Microtheory currently in use.  Assertions in this context are `accessible' from any other Microtheory via the genlMt relation.  In the partial order of microtheories, all microtheories have access to BaseKB.  An assertion which is true here will by default be true in every context.  The `content' of BaseKB consists of very general assertions which are expected to be usable in most or all applications of Cyc, as well as Cyc's most fundamental assertions that it uses in inference, and all completely universal, timeless truths."),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtVariableArityRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtUnreifiableFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttUnitOfMeasure,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtUnaryRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtUnaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtUnaryFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtTruthFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtTransitiveBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtTernaryRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtTernaryFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtSymmetricBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftPositiveInteger,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftNonNegativeInteger,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tSet,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttSiblingDisjointAttributeType,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttSetOrCollection,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tSetMathematical,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtScopingRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(vtScalarPointValue,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(vtScalarIntegralValue,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtReifiableFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtReformulatorDirectivePredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtReflexiveBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftRealNumber,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuintaryRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuintaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuintaryFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuaternaryRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuaternaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuaternaryFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtQuantifier,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(mtProblemSolvingCntxt,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tPred,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftPositiveInteger,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtPartiallyCommutativeRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftNonNegativeScalarInterval,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftNonNegativeInteger,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tMultigraph,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(vtMonthOfYearType,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtMicrotheoryDesignatingRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tMicrotheory,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtLogicalConnective,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftList,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtIrreflexiveBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtInterArgIsaPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtInterArgFormatPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ftInt,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tIndividual,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(mtHypotheticalContext,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(vtFormat,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtFixedAritySkolemFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(cycFixedAritySkolemFuncN,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtFixedArityRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtExistentialQuantifier,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtExceptionPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtEvaluatableRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtEvaluatableFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(iELRelationOneWay,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtDistributingMetaKnowledgePredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttDisjointCollectionType,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tDirectedMultigraph,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtDefaultMonotonicPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttExpressionType,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(vtAssertionDirection,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtCommutativeRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtCollectionDenotingFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(tCol,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(mtBroadMicrotheory,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtBookkeepingPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtBinaryRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtBinaryFunction,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(ttAtemporalNecessarilyEssentialCollectionType,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtAsymmetricBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtAssociativeRelation,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgTypeTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgTypePredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgTypeBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgIsaTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgIsaBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgGenlTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgGenlQuantityTernaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgGenlQuantityBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgGenlBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtArgConstraintPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtAntiTransitiveBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(collectionConventionMt(rtAntiSymmetricBinaryPredicate,iUniversalVocabularyMt),iBaseKB,vStrDef).
tiny_kb(relationAll(minimizeExtent,rtBookkeepingPredicate),iBaseKB,vStrDef).
tiny_kb(implies(nearestCommonSpecs(COL,COL,NEAREST_SPEC),nearestGenls(NEAREST_SPEC,COL)),iBaseKB,vStrDef).
tiny_kb(implies(quotedIsa(ASSERTION,ftRuleAssertion),assertionDirection(ASSERTION,vBackwardAssertionDirection)),iBaseKB,vStrDef).
tiny_kb(implies(quotedIsa(ASSERTION,ftGAFAssertion),assertionDirection(ASSERTION,vForwardAssertionDirection)),iBaseKB,vStrDef).
tiny_kb(implies(quantitySubsumes(NUM2,SUBNUM2),quantitySubsumes(vUnityFn(_NUM1,NUM2),SUBNUM2)),iBaseKB,vStrDef).
tiny_kb(implies(quantitySubsumes(NUM1,SUBNUM1),quantitySubsumes(vUnityFn(NUM1,_NUM2),SUBNUM1)),iBaseKB,vStrDef).
tiny_kb(implies(notAssertible(PRED),abnormal(vTheListFn(PRED),'TINYKB-ASSERTION'(':TRUE-MON',[[[genlPreds,PRED,termDependsOn]],[[afterRemoving,PRED,[uSubLQuoteFn,'REMOVE-DEPENDENT-TERM']]]],iBaseKB,s("?","PRED"),[implies,[genlPreds,PRED,termDependsOn],[afterRemoving,PRED,[uSubLQuoteFn,'REMOVE-DEPENDENT-TERM']]]))),iBaseKB,vStrDef).
tiny_kb(implies(notAssertible(SPEC_PRED),abnormal(vTheListFn(SPEC_PRED),'TINYKB-ASSERTION'(':TRUE-DEF',[[[different,disjointWith,SPEC_PRED],[genlPreds,SPEC_PRED,disjointWith]],[[afterAdding,SPEC_PRED,[uSubLQuoteFn,'PROPAGATE-TO-DISJOINTWITH']]]],iBaseKB,s("?","SPEC-PRED"),[implies,[and,[different,disjointWith,SPEC_PRED],[genlPreds,SPEC_PRED,disjointWith]],[afterAdding,SPEC_PRED,[uSubLQuoteFn,'PROPAGATE-TO-DISJOINTWITH']]]))),iBaseKB,vStrDef).
tiny_kb(implies(operatorFormulas(A,B),natFunction(B,A)),iBaseKB,vStrDef).
tiny_kb(implies(and(rewriteOf(TERM,NART1),rewriteOf(TERM,NART2)),equals(NART1,NART2)),iBaseKB,vStrDef).
tiny_kb(implies(and(requiredArg2Pred(COL_2,PRED),interArgIsa(PRED,2,COL_2,1,COL_1)),relationExistsAll(PRED,COL_1,COL_2)),iBaseKB,vStrDef).
tiny_kb(implies(and(relationAllExistsMax(REL,A,B,N),relationAllExistsMin(REL,A,B,N)),relationAllExistsCount(REL,A,B,N)),iBaseKB,vStrDef).
tiny_kb(implies(and(relationAllExistsCount(REL,COL1,COL2,M),relationAllExistsCount(REL,COL1,COL2,N)),numericallyEquals(M,N)),iBaseKB,vStrDef).
tiny_kb(implies(and(quantitySubsumes(SUPER,SUB),followingValue(SUPER,LATER)),followingValue(SUB,LATER)),iBaseKB,vStrDef).
tiny_kb(implies(and(quantitySubsumes(INTERVAL1,INTERVAL2),quantitySubsumes(INTERVAL2,INTERVAL1)),numericallyEquals(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(termOfUnit(PERFN_1,cycPerFn(UNIT2,UNIT3)),termOfUnit(PERFN_2,cycPerFn(UNIT1,UNIT2)),termOfUnit(PERFN,cycPerFn(UNIT1,UNIT3))),multiplicationUnits(PERFN_1,PERFN_2,PERFN)),iBaseKB,vStrDef).
tiny_kb(implies(ftPositiveInteger(X),greaterThanOrEqualTo(X,1)),iBaseKB,vStrDef).
tiny_kb(implies(and(unitMultiplicationFactor(UNIT_ONE,UNIT_TWO,FACTOR1),termOfUnit(PERFN_1,cycPerFn(UNIT_ONE,UNIT_THREE)),termOfUnit(PERFN,cycPerFn(UNIT_TWO,UNIT_THREE))),unitMultiplicationFactor(PERFN_1,PERFN,FACTOR1)),iBaseKB,vStrDef).
tiny_kb(implies(extentCardinality(tSetOfTheSetOfFn(OBJ,and(isa(OBJ,COLL_1),~isa(OBJ,COLL_2))),0),subsetOf(COLL_1,COLL_2)),iBaseKB,vStrDef).
tiny_kb(implies(extConceptOverlapsColAndReln(COL,RELN,SOURCE,STRING),overlappingExternalConcept(RELN,SOURCE,STRING)),iBaseKB,vStrDef).
tiny_kb(implies(extConceptOverlapsColAndReln(COL,RELN,SOURCE,STRING),overlappingExternalConcept(COL,SOURCE,STRING)),iBaseKB,vStrDef).
tiny_kb(implies(except(ASSERTION),exceptWhen(except(ASSERTION),ASSERTION)),iBaseKB,vStrDef).
tiny_kb(implies(equals(A,B),equalStringsCaseinsensitive(A,B)),iBaseKB,vStrDef).
tiny_kb(implies(elInverse(SLOT,INVERSE),expansion(INVERSE,t(SLOT,':ARG2',':ARG1'))),iBaseKB,vStrDef).
tiny_kb(implies(integerBetween(LOW,MED,HIGH),greaterThanOrEqualTo(MED,LOW)),iBaseKB,vStrDef).
tiny_kb(implies(integerBetween(LOW,MED,HIGH),greaterThanOrEqualTo(HIGH,MED)),iBaseKB,vStrDef).
tiny_kb(implies(holdsIn(_T1,holdsIn(T2,P)),holdsIn(T2,P)),iBaseKB,vStrDef).
tiny_kb(implies(call_u_no_bc(interArgResultIsa(FUNC,ARG,INDEP_COL,DEP_COL)),meetsPragmaticRequirement(vTheListFn(NAT,FUNC,TERM,INDEP_COL,ARG,DEP_COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[natFunction,NAT,FUNC],[isa,TERM,INDEP_COL],[natArgument,NAT,ARG,TERM],[interArgResultIsa,FUNC,ARG,INDEP_COL,DEP_COL]],[[isa,NAT,DEP_COL]]],iBaseKB,s("?NAT","?FUNC","?TERM","?INDEP-COL","?ARG","?DEP-COL"),[implies,[and,[natFunction,NAT,FUNC],[isa,TERM,INDEP_COL],[natArgument,NAT,ARG,TERM],[interArgResultIsa,FUNC,ARG,INDEP_COL,DEP_COL]],[isa,NAT,DEP_COL]]))),iBaseKB,vStrDef).
tiny_kb(implies(call_u_no_bc(genlPreds(SPEC,PRED)),meetsPragmaticRequirement(vTheListFn(PRED,MT,SPEC),'TINYKB-ASSERTION'(':TRUE-DEF',[[[decontextualizedPredicate,PRED],[predicateConventionMt,PRED,MT],[genlPreds,SPEC,PRED]],[[predicateConventionMt,SPEC,MT]]],iBaseKB,s("?PRED","?MT","?SPEC"),[implies,[and,[decontextualizedPredicate,PRED],[predicateConventionMt,PRED,MT],[genlPreds,SPEC,PRED]],[predicateConventionMt,SPEC,MT]]))),iBaseKB,vStrDef).
tiny_kb(implies(admittedSentence(isa(A,B)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[elementOf,A,B]],[[isa,A,B]]],iBaseKB,s("?A","?B"),[implies,[elementOf,A,B],[isa,A,B]]))),iBaseKB,vStrDef).
tiny_kb(implies(admittedSentence(genls(A,B)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[subsetOf,A,B]],[[genls,A,B]]],iBaseKB,s("?A","?B"),[implies,[subsetOf,A,B],[genls,A,B]]))),iBaseKB,vStrDef).
tiny_kb(implies(admittedSentence(equalStringsCaseinsensitive(A,B)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[equals,A,B]],[[equalStringsCaseinsensitive,A,B]]],iBaseKB,s("?A","?B"),[implies,[equals,A,B],[equalStringsCaseinsensitive,A,B]]))),iBaseKB,vStrDef).
tiny_kb(implies(and(minQuantValue(VALUE1,VALUE1MIN),maxQuantValue(VALUE2,VALUE2MAX),greaterThan(VALUE1MIN,VALUE2MAX)),greaterThan(VALUE1,VALUE2)),iBaseKB,vStrDef).
tiny_kb(implies(and(minQuantValue(MORE,MOREMIN),greaterThan(MORE,LESS),maxQuantValue(LESS,LESSMAX)),greaterThan(MOREMIN,LESSMAX)),iBaseKB,vStrDef).
tiny_kb(implies(and(minQuantValue(INTERVAL1,VALUE),maxQuantValue(INTERVAL2,VALUE)),quantityIntersects(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(minQuantValue(INTERVAL1,MIN),minQuantValue(INTERVAL2,MIN)),quantityIntersects(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(maxQuantValue(INTERVAL1,MAX1),minQuantValue(INTERVAL1,MIN1),minQuantValue(INTERVAL2,MIN2),maxQuantValue(INTERVAL2,MAX2),greaterThanOrEqualTo(MAX1,MAX2),greaterThanOrEqualTo(MIN2,MIN1)),quantitySubsumes(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(maxQuantValue(INTERVAL1,MAX1),minQuantValue(INTERVAL1,MIN1),minQuantValue(INTERVAL2,MIN2),greaterThanOrEqualTo(MIN2,MIN1),greaterThanOrEqualTo(MAX1,MIN2)),quantityIntersects(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(maxQuantValue(INTERVAL1,MAX1),minQuantValue(INTERVAL1,MIN1),maxQuantValue(INTERVAL2,MAX2),greaterThanOrEqualTo(MAX2,MIN1),greaterThanOrEqualTo(MAX1,MAX2)),quantityIntersects(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(maxQuantValue(INTERVAL1,MAX),maxQuantValue(INTERVAL2,MAX)),quantityIntersects(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),quantityIntersects(t(UNIT,NUM1A,NUM1B),t(UNIT,NUM2A,NUM2B))),quantityIntersects(vUnityFn(NUM1A,NUM1B),vUnityFn(NUM2A,NUM2B))),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),quantityIntersects(isa(NUM1,UNIT),isa(NUM2,UNIT))),quantityIntersects(NUM1,NUM2)),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),vtScalarIntegralValue(t(UNIT,M)),vtScalarIntegralValue(t(UNIT,N)),evaluate(DIFFERENCEFN,vDifferenceFn(isa(M,UNIT),isa(N,UNIT)))),vtScalarIntegralValue(DIFFERENCEFN)),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),greaterThan(t(UNIT,NUM1A,NUM1B),t(UNIT,NUM2A,NUM2B))),greaterThan(vUnityFn(NUM1A,NUM1B),vUnityFn(NUM2A,NUM2B))),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),greaterThan(isa(NUM1,UNIT),isa(NUM2,UNIT))),greaterThan(NUM1,NUM2)),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(UNIT),equals(QUANT,isa(NUM,UNIT))),equals(QUANT,t(UNIT,NUM,NUM))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(THING,UNIVCOL),relationAllExists(PRED,UNIVCOL,EXISTCOL)),trueSentence(exists(OTHER,and(isa(OTHER,EXISTCOL),t(PRED,THING,OTHER))))),iBaseKB,vStrDef).
tiny_kb(implies(and(ttUnitOfMeasure(SMALLER_UNIT),ttUnitOfMeasure(LARGER_UNIT),unitMultiplicationFactor(SMALLER_UNIT,LARGER_UNIT,N),evaluate(TIMESFN,vTimesFn(M,isa(N,SMALLER_UNIT)))),equals(TIMESFN,isa(M,LARGER_UNIT))),iBaseKB,vStrDef).
tiny_kb(implies(and(rtIrreflexiveBinaryPredicate(SLOT),rtTransitiveBinaryPredicate(SLOT)),rtAsymmetricBinaryPredicate(SLOT)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtAntiSymmetricBinaryPredicate(SLOT),rtIrreflexiveBinaryPredicate(SLOT)),rtAsymmetricBinaryPredicate(SLOT)),iBaseKB,vStrDef).
tiny_kb(implies(and(tSet(SIBDIS_COL),isa(COL1,SIBDIS_COL),isa(COL2,SIBDIS_COL)),or(genls(COL1,COL2),disjointWith(COL1,COL2),siblingDisjointExceptions(COL1,COL2),genls(COL2,COL1))),iBaseKB,vStrDef).
tiny_kb(implies(and(rtMicrotheoryDesignatingRelation(RELN),sentenceDesignationArgnum(RELN,NUM)),argIsa(RELN,NUM,ftSentenceAssertible)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtMicrotheoryDesignatingRelation(RELN),microtheoryDesignationArgnum(RELN,NUM)),argIsa(RELN,NUM,tMicrotheory)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtMicrotheoryDesignatingRelation(RELN),rtVariableArityRelation(RELN),arityMin(RELN,ARITY_MIN)),greaterThanOrEqualTo(ARITY_MIN,2)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtFixedArityRelation(RELN),rtMicrotheoryDesignatingRelation(RELN),arity(RELN,ARITY)),greaterThanOrEqualTo(ARITY,2)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTransitiveBinaryPredicate(REL),relationExistsMaxAll(REL,TYPE2,TYPE3,1),relationAllExistsCount(REL,TYPE1,TYPE2,X),relationAllExistsCount(REL,TYPE2,TYPE3,Y),evaluate(TIMESFN,vTimesFn(X,Y))),relationAllExistsMin(REL,TYPE1,TYPE3,TIMESFN)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtPartiallyCommutativeRelation(REL),arity(REL,N)),greaterThanOrEqualTo(N,3)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTransitiveBinaryPredicate(PRED),relationAllExists(PRED,COL1,COL2),relationAllExists(PRED,COL2,COL3)),relationAllExists(PRED,COL1,COL3)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTransitiveBinaryPredicate(PRED),holdsIn(TIME,t(PRED,ARG1,ARG2)),holdsIn(TIME,t(PRED,ARG2,ARG3))),holdsIn(TIME,t(PRED,ARG1,ARG3))),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTransitiveBinaryPredicate(PRED),t(PRED,X,Y),t(PRED,Y,Z)),t(PRED,X,Z)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTernaryPredicate(PRED),commutativeInArgs(PRED,2,3),t(PRED,ARG1,ARG2,ARG3)),t(PRED,ARG1,ARG3,ARG2)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTernaryPredicate(PRED),commutativeInArgs(PRED,1,3),t(PRED,ARG1,ARG2,ARG3)),t(PRED,ARG3,ARG2,ARG1)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtTernaryPredicate(PRED),commutativeInArgs(PRED,1,2),t(PRED,ARG1,ARG2,ARG3)),t(PRED,ARG2,ARG1,ARG3)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(PRED),t(PRED,ARG1,ARG2)),t(PRED,ARG2,ARG1)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(PRED),genlPreds(PRED,GENL_PRED),t(PRED,ARG_1,ARG_2)),t(GENL_PRED,ARG_2,ARG_1)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,3,4),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG1,ARG2,ARG4,ARG3)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,2,4),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG1,ARG4,ARG3,ARG2)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,2,3),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG1,ARG3,ARG2,ARG4)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,1,4),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG4,ARG2,ARG3,ARG1)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,1,3),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG3,ARG2,ARG1,ARG4)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtQuaternaryPredicate(PRED),commutativeInArgs(PRED,1,2),t(PRED,ARG1,ARG2,ARG3,ARG4)),t(PRED,ARG2,ARG1,ARG3,ARG4)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtIrreflexiveBinaryPredicate(PRED),t(PRED,OBJ1,OBJ2)),different(OBJ1,OBJ2)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtFixedArityRelation(PRED),arity(PRED,ARITY),genlPreds(SPECPRED,PRED)),arity(SPECPRED,ARITY)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(OBJECT2,TYPE),t(RELATION,OBJECT1,OBJECT2)),relationInstanceExists(RELATION,OBJECT1,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(OBJECT1,TYPE),t(RELATION,OBJECT1,OBJECT2)),relationExistsInstance(RELATION,TYPE,OBJECT2)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(OBJ_1,COMMON_NEAR),isa(OBJ_2,COMMON_NEAR)),or(nearestCommonIsa(OBJ_1,OBJ_2,COMMON_NEAR),elementOf(COMMON_NEAR,tSetOfTheSetOfFn(COMMON_FARTHER,exists(COMMON_FAR,and(isa(OBJ_1,COMMON_FAR),isa(OBJ_2,COMMON_FAR),genls(COMMON_FAR,COMMON_FARTHER),different(COMMON_FAR,COMMON_FARTHER))))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(OBJ,COL),conceptuallyRelated(COL,REL_OBJ)),conceptuallyRelated(OBJ,REL_OBJ)),iBaseKB,vStrDef).
tiny_kb(implies(and(vtScalarPointValue(LOW),ttUnitOfMeasure(UNIT)),minQuantValue(t(UNIT,LOW,HIGH),isa(LOW,UNIT))),iBaseKB,vStrDef).
tiny_kb(implies(and(vtScalarPointValue(INTERVAL1),vtScalarPointValue(INTERVAL2),quantityIntersects(INTERVAL1,INTERVAL2)),numericallyEquals(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(vtScalarInterval(INTERVAL1),vtScalarInterval(INTERVAL2),equals(INTERVAL1,INTERVAL2)),numericallyEquals(INTERVAL1,INTERVAL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INST_UNIV,UNIV_COL),relationAllExistsCount(REL,UNIV_COL,EXIST_COL,NUM)),trueSentence(thereExistExactly(NUM,INST_EXIST,and(isa(INST_EXIST,EXIST_COL),t(REL,INST_UNIV,INST_EXIST))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INST,COL),relationInstanceAll(PRED,THING,COL)),t(PRED,THING,INST)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INST,COL),relationAllInstance(PRED,COL,THING)),trueSentence(t(PRED,INST,THING))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INST,COL),relationAllInstance(PRED,COL,THING)),t(PRED,INST,THING)),iBaseKB,vStrDef).
tiny_kb(implies(and(tPred(INS1),rtSymmetricBinaryPredicate(INS2),ftPositiveInteger(INS3),transitiveViaArgInverse(INS1,INS2,INS3)),transitiveViaArg(INS1,INS2,INS3)),iBaseKB,vStrDef).
tiny_kb(implies(and(tPred(INS1),rtSymmetricBinaryPredicate(INS2),ftPositiveInteger(INS3),transitiveViaArg(INS1,INS2,INS3)),transitiveViaArgInverse(INS1,INS2,INS3)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INS,COL),trueSentence(t(PRED,INS,VALUE))),relationExistsInstance(PRED,COL,VALUE)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),t(PRED,DEP_INS,INDEP_INS),interArgIsa(PRED,2,INDEP_COL,1,DEP_COL)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,5,INDEP_COL,4,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,ANY_ARG_3,DEP_INS,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,5,INDEP_COL,3,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,DEP_INS,ANY_ARG_4,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,5,INDEP_COL,2,DEP_COL),t(PRED,ANY_ARG_1,DEP_INS,ANY_ARG_3,ANY_ARG_4,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,5,INDEP_COL,1,DEP_COL),t(PRED,DEP_INS,ANY_ARG_2,ANY_ARG_3,ANY_ARG_4,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,4,INDEP_COL,5,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,ANY_ARG_3,INDEP_INS,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,4,INDEP_COL,3,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,DEP_INS,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,4,INDEP_COL,2,DEP_COL),t(PRED,ANY_ARG_1,DEP_INS,ANY_ARG_3,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,4,INDEP_COL,1,DEP_COL),t(PRED,DEP_INS,ANY_ARG_2,ANY_ARG_3,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,3,INDEP_COL,5,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,INDEP_INS,ANY_ARG_4,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,3,INDEP_COL,4,DEP_COL),t(PRED,ANY_ARG_1,ANY_ARG_2,INDEP_INS,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,3,INDEP_COL,2,DEP_COL),t(PRED,ANY_ARG_1,DEP_INS,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,3,INDEP_COL,1,DEP_COL),t(PRED,DEP_INS,ANY_ARG_2,INDEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,2,INDEP_COL,5,DEP_COL),t(PRED,ANY_ARG_1,INDEP_INS,ANY_ARG_3,ANY_ARG_4,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,2,INDEP_COL,4,DEP_COL),t(PRED,ANY_ARG_1,INDEP_INS,ANY_ARG_3,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,2,INDEP_COL,3,DEP_COL),t(PRED,ANY_ARG_1,INDEP_INS,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,1,INDEP_COL,5,DEP_COL),t(PRED,INDEP_INS,ANY_ARG_2,ANY_ARG_3,ANY_ARG_4,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,1,INDEP_COL,4,DEP_COL),t(PRED,INDEP_INS,ANY_ARG_2,ANY_ARG_3,DEP_INS)),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(vtScalarPointValue(HIGH),vtScalarPointValue(LOW),ttUnitOfMeasure(UNIT)),maxQuantValue(t(UNIT,LOW,HIGH),isa(HIGH,UNIT))),iBaseKB,vStrDef).
tiny_kb(implies(and(tFunction(FUNCTION),quotedIsa(FUNCTION,ftConstant)),or(rtReifiableFunction(FUNCTION),rtUnreifiableFunction(FUNCTION))),iBaseKB,vStrDef).
tiny_kb(implies(and(tFunction(FUNC),arity(FUNC,5)),rtQuintaryFunction(FUNC)),iBaseKB,vStrDef).
tiny_kb(implies(and(tFunction(FUN),arity(FUN,2)),rtBinaryFunction(FUN)),iBaseKB,vStrDef).
tiny_kb(implies(and(ttDisjointCollectionType(DIS_COL_TYPE),isa(COL1,DIS_COL_TYPE),isa(COL2,DIS_COL_TYPE),different(COL1,COL2)),disjointWith(COL1,COL2)),iBaseKB,vStrDef).
tiny_kb(implies(and(tCol(COL),rtBinaryPredicate(RELN),overlappingExternalConcept(RELN,SOURCE,STRING),overlappingExternalConcept(COL,SOURCE,STRING)),extConceptOverlapsColAndReln(COL,RELN,SOURCE,STRING)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(BPRED),transitiveViaArgInverse(PRED,BPRED,N)),transitiveViaArg(PRED,BPRED,N)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtSymmetricBinaryPredicate(BPRED),transitiveViaArg(PRED,BPRED,N)),transitiveViaArgInverse(PRED,BPRED,N)),iBaseKB,vStrDef).
tiny_kb(implies(and(rtArgIsaBinaryPredicate(ARG_ISA_PRED),constrainsArg(ARG_ISA_PRED,N),preservesGenlsInArg(FUNC,N)),t(ARG_ISA_PRED,FUNC,tCol)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(ARG2,UNIV_COL),relationExistsMinAll(SLOT,EXIST_COL,UNIV_COL,NUM)),trueSentence(thereExistAtLeast(NUM,ARG,and(isa(ARG,EXIST_COL),t(SLOT,ARG,ARG2))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(ARG2,UNIV_COL),relationExistsMaxAll(SLOT,EXIST_COL,UNIV_COL,NUM)),trueSentence(thereExistAtMost(NUM,ARG,and(isa(ARG,EXIST_COL),t(SLOT,ARG,ARG2))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(ARG2,UNIV_COL),relationExistsCountAll(SLOT,EXIST_COL,UNIV_COL,NUM)),trueSentence(thereExistExactly(NUM,ARG1,and(isa(ARG1,EXIST_COL),t(SLOT,ARG1,ARG2))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(ARG1,UNIV_COL),relationAllExistsMin(SLOT,UNIV_COL,EXIST_COL,NUM)),trueSentence(thereExistAtLeast(NUM,ARG,and(isa(ARG,EXIST_COL),t(SLOT,ARG1,ARG))))),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(ARG1,UNIV_COL),relationAllExistsMax(SLOT,UNIV_COL,EXIST_COL,NUM)),trueSentence(thereExistAtMost(NUM,ARG,and(isa(ARG,EXIST_COL),t(SLOT,ARG1,ARG))))),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(5,N),argIsa(PRED,6,TYPE)),argIsa(iFunctionToArgFn(N,PRED),5,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(4,N),argIsa(PRED,5,TYPE)),argIsa(iFunctionToArgFn(N,PRED),4,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(3,N),argIsa(PRED,4,TYPE)),argIsa(iFunctionToArgFn(N,PRED),3,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(2,N),argIsa(PRED,3,TYPE)),argIsa(iFunctionToArgFn(N,PRED),2,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(1,N),argIsa(PRED,2,TYPE)),argIsa(iFunctionToArgFn(N,PRED),1,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThanOrEqualTo(N,ARGNUM),argAndRestIsa(PRED,ARGNUM,COL)),argIsa(PRED,N,COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(NUM,0),relationExistsMinAll(SLOT,EXIST_COL,UNIV_COL,NUM)),relationExistsAll(SLOT,EXIST_COL,UNIV_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(NUM,0),relationExistsCountAll(SLOT,EXIST_COL,UNIV_COL,NUM)),relationExistsAll(SLOT,EXIST_COL,UNIV_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(NUM,0),relationAllExistsMin(SLOT,UNIV_COL,EXIST_COL,NUM)),relationAllExists(SLOT,UNIV_COL,EXIST_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(NUM,0),relationAllExistsCount(SLOT,UNIV_COL,EXIST_COL,NUM)),relationAllExists(SLOT,UNIV_COL,EXIST_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(NUM,0),greaterThanOrEqualTo(ARITY,NUM),arity(FN,ARITY),resultIsa(FN,COLL)),interArgResultIsa(FN,NUM,tThing,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(N,5),argIsa(PRED,5,TYPE)),argIsa(iFunctionToArgFn(N,PRED),5,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(N,4),argIsa(PRED,4,TYPE)),argIsa(iFunctionToArgFn(N,PRED),4,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(N,3),argIsa(PRED,3,TYPE)),argIsa(iFunctionToArgFn(N,PRED),3,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(N,2),argIsa(PRED,2,TYPE)),argIsa(iFunctionToArgFn(N,PRED),2,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(greaterThan(N,1),argIsa(PRED,1,TYPE)),argIsa(iFunctionToArgFn(N,PRED),1,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(genls(X,larkcPlugin),larkcHasOutputType(X,TYPE),genls(TYPE,TYPE1),larkcHasInputType(Y,TYPE1),genls(Y,larkcPlugin)),larkcPluginByDataConnectsTo(X,Y)),iBaseKB,vStrDef).
tiny_kb(implies(and(genls(SPEC,COL),conceptuallyRelated(COL,REL_OBJ)),conceptuallyRelated(SPEC,REL_OBJ)),iBaseKB,vStrDef).
tiny_kb(implies(and(genls(INDEP_SPEC,INDEP_COL),t(PRED,INDEP_SPEC,DEP_SPEC),interArgGenl(PRED,1,INDEP_COL,2,DEP_COL)),genls(DEP_SPEC,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(genls(COL_1,COMMON_NEAR),different(COL_1,COMMON_NEAR),genls(COL_2,COMMON_NEAR),different(COL_2,COMMON_NEAR)),or(nearestCommonGenls(COL_1,COL_2,COMMON_NEAR),elementOf(COMMON_NEAR,tSetOfTheSetOfFn(COMMON_FARTHER,exists(COMMON_FAR,and(genls(COL_1,COMMON_FAR),genls(COL_2,COMMON_FAR),genls(COMMON_FAR,COMMON_FARTHER),different(COL_1,COMMON_FAR),different(COL_2,COMMON_FAR),different(COMMON_FAR,COMMON_FARTHER))))))),iBaseKB,vStrDef).
tiny_kb(implies(and(genls(COL,NEAR_COL),different(COL,NEAR_COL),unknownSentence(exists(BETWEEN,and(genls(BETWEEN,NEAR_COL),genls(COL,BETWEEN),different(BETWEEN,COL,NEAR_COL))))),nearestGenls(COL,NEAR_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(genlPreds(SPEC_PRED,PRED),genls(EXISTS_SPEC,EXISTS_COL),genls(ALL_SPEC,ALL_COL),greaterThanOrEqualTo(MORE,MAX),relationExistsMaxAll(PRED,EXISTS_COL,ALL_COL,MAX)),relationExistsMaxAll(SPEC_PRED,EXISTS_SPEC,ALL_SPEC,MORE)),iBaseKB,vStrDef).
tiny_kb(implies(and(genlPreds(SPEC_PRED,GENL_PRED),unknownSentence(exists(DIR,reformulationDirectionInMode(DIR,MODE,RULE))),defaultReformulationDirectionInModeForPred(DEFAULT_DIR,MODE,GENL_PRED),evaluate(SPEC_PRED,uFormulaArgFn(0,RULE))),reformulationDirectionInMode(DEFAULT_DIR,MODE,RULE)),iBaseKB,vStrDef).
tiny_kb(implies(and(genlPreds(SPEC_PRED,GENL_PRED),relationAllExists(SPEC_PRED,COL_1,COL_2)),relationAllExists(GENL_PRED,COL_1,COL_2)),iBaseKB,vStrDef).
tiny_kb(implies(and(genlPreds(SPEC_PRED,GENL_PRED),relationAll(SPEC_PRED,COL)),relationAll(GENL_PRED,COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(genlPreds(SPEC,GENL),fanOutArg(GENL,ARG_NUM)),fanOutArg(SPEC,ARG_NUM)),iBaseKB,vStrDef).
tiny_kb(implies(and(evaluate(FUNCTION,uFormulaArgFn(0,NAT)),termOfUnit(NAT,FORMULA)),natFunction(NAT,FUNCTION)),iBaseKB,vStrDef).
tiny_kb(implies(and(equals(X,Y),isa(X,COL)),isa(Y,COL)),iBaseKB,vStrDef).
tiny_kb(implies(evaluate(QUOTIENTFN,vQuotientFn(NUM_1,NUM_2)),ratioOfTo(NUM_1,NUM_2,QUOTIENTFN)),iBaseKB,vStrDef).
tiny_kb(implies(evaluate(FORMULAARGFN,uFormulaArgFn(0,FORMULA)),operatorFormulas(FORMULAARGFN,FORMULA)),iBaseKB,vStrDef).
tiny_kb(implies(and(different(disjointWith,SPEC_PRED),genlPreds(SPEC_PRED,disjointWith)),afterAdding(SPEC_PRED,uSubLQuoteFn('PROPAGATE-TO-DISJOINTWITH'))),iBaseKB,vStrDef).
tiny_kb(implies(and(different(X,Y),different(Y,Z)),meetsPragmaticRequirement(vTheListFn(PRED,X,Y,Z),'TINYKB-ASSERTION'(':TRUE-DEF',[[[isa,PRED,rtTransitiveBinaryPredicate],[PRED,X,Y],[PRED,Y,Z]],[[PRED,X,Z]]],iBaseKB,s("?PRED","?X","?Y","?Z"),[implies,[and,[isa,PRED,rtTransitiveBinaryPredicate],[PRED,X,Y],[PRED,Y,Z]],[PRED,X,Z]]))),iBaseKB,vStrDef).
tiny_kb(implies(and(decontextualizedPredicate(PRED),predicateConventionMt(PRED,MT),genlPreds(SPEC,PRED)),predicateConventionMt(SPEC,MT)),iBaseKB,vStrDef).
tiny_kb(implies(and(completelyEnumerableCollection(COL),isa(INST,COL)),knownSentence(isa(INST,COL))),iBaseKB,vStrDef).
tiny_kb(implies(and(completelyDecidableCollection(COLL_2),completelyDecidableCollection(COLL_1)),meetsPragmaticRequirement(vTheListFn(COLL_2,COLL_1),'TINYKB-ASSERTION'(':TRUE-DEF',[[[extentCardinality,[tSetOfTheSetOfFn,'?OBJ',[and,[isa,'?OBJ',COLL_1],[not,[isa,'?OBJ',COLL_2]]]],0]],[[subsetOf,COLL_1,COLL_2]]],iBaseKB,s("?COLL-2","?COLL-1"),[implies,[extentCardinality,[tSetOfTheSetOfFn,'?OBJ',[and,[isa,'?OBJ',COLL_1],[not,[isa,'?OBJ',COLL_2]]]],0],[subsetOf,COLL_1,COLL_2]]))),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(REL,5,COLL),admittedArgument(TERM,5,REL)),isa(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argGenl(REL,5,COLL),admittedArgument(TERM,5,REL)),genls(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(REL,4,COLL),admittedArgument(TERM,4,REL)),isa(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argGenl(REL,4,COLL),admittedArgument(TERM,4,REL)),genls(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(REL,3,COLL),admittedArgument(TERM,3,REL)),isa(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argGenl(REL,3,COLL),admittedArgument(TERM,3,REL)),genls(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(ROLE,2,TYPE),requiredArg1Pred(SITTYPE,ROLE),isa(SIT,SITTYPE)),relationInstanceExists(ROLE,SIT,TYPE)),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(REL,2,COLL),admittedArgument(TERM,2,REL)),isa(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argGenl(REL,2,COLL),admittedArgument(TERM,2,REL)),genls(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argIsa(REL,1,COLL),admittedArgument(TERM,1,REL)),isa(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(argGenl(REL,1,COLL),admittedArgument(TERM,1,REL)),genls(TERM,COLL)),iBaseKB,vStrDef).
tiny_kb(implies(and(admittedSentence(FORMULA),integerBetween(1,ARG,ARITY),evaluate(RELATION,uFormulaArgFn(0,FORMULA)),evaluate(ARITY,vFormulaArityFn(FORMULA)),evaluate(TERM,uFormulaArgFn(ARG,FORMULA))),admittedArgument(TERM,ARG,RELATION)),iBaseKB,vStrDef).
tiny_kb(implies(and(admittedArgument(B,1,natFunction),admittedArgument(A,2,natFunction)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[operatorFormulas,A,B]],[[natFunction,B,A]]],iBaseKB,s("?A","?B"),[implies,[operatorFormulas,A,B],[natFunction,B,A]]))),iBaseKB,vStrDef).
tiny_kb(implies(and(admittedArgument(A,1,isa),admittedArgument(B,2,isa)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[elementOf,A,B]],[[isa,A,B]]],iBaseKB,s("?A","?B"),[implies,[elementOf,A,B],[isa,A,B]]))),iBaseKB,vStrDef).
tiny_kb(implies(and(admittedArgument(A,1,genls),admittedArgument(B,2,genls)),meetsPragmaticRequirement(vTheListFn(A,B),'TINYKB-ASSERTION'(':TRUE-DEF',[[[subsetOf,A,B]],[[genls,A,B]]],iBaseKB,s("?A","?B"),[implies,[subsetOf,A,B],[genls,A,B]]))),iBaseKB,vStrDef).
tiny_kb(implies(unknownSentence(disjointWith(COL1,COL2)),consistent(and(isa(THING,COL1),isa(THING,COL2)))),iBaseKB,vStrDef).
tiny_kb(implies(trueSentence(exists(X,and(isa(X,COL),unknownSentence(isa(X,GENL_PRED))))),meetsPragmaticRequirement(vTheListFn(SPEC_PRED,GENL_PRED,COL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[genlPreds,SPEC_PRED,GENL_PRED],[relationAll,SPEC_PRED,COL]],[[relationAll,GENL_PRED,COL]]],iBaseKB,s("?SPEC-PRED","?GENL-PRED","?COL"),[implies,[and,[genlPreds,SPEC_PRED,GENL_PRED],[relationAll,SPEC_PRED,COL]],[relationAll,GENL_PRED,COL]]))),iBaseKB,vStrDef).
tiny_kb(implies(trueSentence(all(ISA_CONSTR,implies(argIsa(PRED,N,ISA_CONSTR),genls(ISA_CONSTR,ftExpression)))),quotedArgument(PRED,N)),iBaseKB,vStrDef).
tiny_kb(implies(trueRule(TEMPLATE,FORMULA),trueSentence(FORMULA)),iBaseKB,vStrDef).
tiny_kb(implies(termOfUnit(UNITPRODUCTFN,cycUnitProductFn(X,Y)),multiplicationUnits(X,Y,UNITPRODUCTFN)),iBaseKB,vStrDef).
tiny_kb(implies(termOfUnit(PERFN,cycPerFn(UOM1,UOM2)),multiplicationUnits(PERFN,UOM2,UOM1)),iBaseKB,vStrDef).
tiny_kb(implies(termOfUnit(MEANINGINSYSTEMFN,iMeaningInSystemFn(SYSTEM,STRING)),synonymousExternalConcept(MEANINGINSYSTEMFN,SYSTEM,STRING)),iBaseKB,vStrDef).
tiny_kb(implies(subsetOf(A,B),genls(A,B)),iBaseKB,vStrDef).
tiny_kb(implies(relationInstanceExists(PRED,THING,COL),trueSentence(exists(INST,and(isa(INST,COL),t(PRED,THING,INST))))),iBaseKB,vStrDef).
tiny_kb(implies(relationInstanceAll(PRED,COL1,COL2),requiredArg2Pred(COL2,PRED)),iBaseKB,vStrDef).
tiny_kb(implies(relationExistsInstance(PRED,COL,THING),trueSentence(exists(INST,and(isa(INST,COL),t(PRED,INST,THING))))),iBaseKB,vStrDef).
tiny_kb(implies(relationExistsAll(SLOT,UNIV_COL,EXIST_COL),relationExistsMinAll(SLOT,UNIV_COL,EXIST_COL,1)),iBaseKB,vStrDef).
tiny_kb(implies(relationExistsAll(PRED,COL1,COL2),requiredArg2Pred(COL2,PRED)),iBaseKB,vStrDef).
tiny_kb(implies(relationAllExists(SLOT,UNIV_COL,EXIST_COL),relationAllExistsMin(SLOT,UNIV_COL,EXIST_COL,1)),iBaseKB,vStrDef).
tiny_kb(implies(relationAllExists(PRED,COL1,_COL2),requiredArg1Pred(COL1,PRED)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,1,INDEP_COL,3,DEP_COL),t([PRED,INDEP_INS,_ANY_ARG_2,DEP_INS|_ARGS])),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(and(isa(INDEP_INS,INDEP_COL),interArgIsa(PRED,1,INDEP_COL,2,DEP_COL),t([PRED,INDEP_INS,DEP_INS|_ARGS])),isa(DEP_INS,DEP_COL)),iBaseKB,vStrDef).
tiny_kb(implies(elementOf(A,B),isa(A,B)),iBaseKB,vStrDef).
tiny_kb(implies(ttUnitOfMeasure(UNIT),equals('NART'([UNIT|ARGS]),'NART'([UNIT,'NART'([vUnityFn|ARGS])]))),iBaseKB,vStrDef).
tiny_kb(implies(and(t([SPEC|ARGS]),genlPreds(SPEC,GENL)),t([GENL|ARGS])),iBaseKB,vStrDef).
tiny_kb(decontextualizedPredicate(nearestGenlMt),iBaseKB,vStrDef).
tiny_kb(decontextualizedPredicate(evaluateImmediately),iBaseKB,vStrDef).
tiny_kb(decontextualizedPredicate(canonicalizerDirectiveForArgAndRest),iBaseKB,vStrDef).
tiny_kb(decontextualizedPredicate(istAsserted),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtVariableArityRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtUnreifiableFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ttUnitOfMeasure),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtUnaryRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtUnaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtUnaryFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtTruthFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtTransitiveBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtTernaryRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtTernaryFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtSymmetricBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftPositiveInteger),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftNonNegativeInteger),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tSet),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ttSiblingDisjointAttributeType),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ttSetOrCollection),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tSetMathematical),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtScopingRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtScalarPointValue),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtScalarInterval),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtScalarIntegralValue),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtReifiableFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtReformulatorDirectivePredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtReflexiveBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftRealNumber),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuintaryRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuintaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuintaryFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuaternaryRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuaternaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuaternaryFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtQuantifier),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(mtProblemSolvingCntxt),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tPred),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftPositiveInteger),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtPartiallyCommutativeRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftNonNegativeScalarInterval),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftNonNegativeInteger),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tMultigraph),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtMonthOfYearType),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtMicrotheoryDesignatingRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtLogicalConnective),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftList),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtIrreflexiveBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtInterArgIsaPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtInterArgFormatPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ftInt),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tIndividual),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(mtHypotheticalContext),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtFormat),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtFixedAritySkolemFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(cycFixedAritySkolemFuncN),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtFixedArityRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtExistentialQuantifier),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtExceptionPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtEvaluatableRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtEvaluatableFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(iELRelationOneWay),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtDistributingMetaKnowledgePredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ttDisjointCollectionType),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tDirectedMultigraph),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtDefaultMonotonicPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(ttExpressionType),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(vtAssertionDirection),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtCommutativeRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtCollectionDenotingFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(tCol),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtBookkeepingPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtBinaryRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtBinaryFunction),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtAsymmetricBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtAssociativeRelation),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgTypeTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgTypePredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgTypeBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgIsaTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgIsaBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgGenlTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgGenlQuantityTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgGenlQuantityBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgGenlBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtArgConstraintPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtAntiTransitiveBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(decontextualizedCollection(rtAntiSymmetricBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(not(commutativeInArgsAndRest(REL,1,2,3)),iBaseKB,vStrDef).
tiny_kb(not(commutativeInArgsAndRest(REL,1,2)),iBaseKB,vStrDef).
tiny_kb(not(commutativeInArgsAndRest(REL,1)),iBaseKB,vStrDef).
tiny_kb(not(and(scopingArg(RELN,N),arity(RELN,ARITY),greaterThan(N,ARITY))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,1),commutativeInArgsAndRest(REL,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,1),commutativeInArgs(REL,M,N))),iBaseKB,vStrDef).
tiny_kb(backchainForbidden(salientAssertions),iBaseKB,vStrDef).
tiny_kb(minimize(disjointWith(COL,COL)),iBaseKB,vStrDef).
tiny_kb(completelyEnumerableCollection(ftTheTerm),iBaseKB,vStrDef).
tiny_kb(completelyEnumerableCollection(rtArgGenlQuantityTernaryPredicate),iBaseKB,vStrDef).
tiny_kb(completelyEnumerableCollection(rtArgGenlQuantityBinaryPredicate),iBaseKB,vStrDef).
tiny_kb(completeExtentAsserted(salientAssertions),iBaseKB,vStrDef).
tiny_kb(not(and(rtTernaryPredicate(X),argIsa(X,4,Y))),iBaseKB,vStrDef).
tiny_kb(not(and(relationAllInstance(PRED,COL,THING),trueSentence(exists(INST,and(isa(INST,COL),not(t(PRED,INST,THING))))))),iBaseKB,vStrDef).
tiny_kb(not(and(relationAllInstance(PRED,COL,THING),trueSentence(exists(COLINST,and(isa(COLINST,COL),not(t(PRED,COLINST,THING))))))),iBaseKB,vStrDef).
tiny_kb(not(and(relationAllExists(RELATION,COL1,COL2),relationAllExistsCount(RELATION,COL1,COL2,0))),iBaseKB,vStrDef).
tiny_kb(not(and(quantitySubsumes(SUPER,SUB),maxQuantValue(SUPER,SUPERMAX),greaterThan(SUBMAX,SUPERMAX),maxQuantValue(SUB,SUBMAX))),iBaseKB,vStrDef).
tiny_kb(not(and(opaqueArgument(REL,N),arity(REL,ARITY),greaterThan(N,ARITY))),iBaseKB,vStrDef).
tiny_kb(not(and(negationInverse(BINPRED1,BINPRED2),t(BINPRED1,ARG1,ARG2),t(BINPRED2,ARG2,ARG1))),iBaseKB,vStrDef).
tiny_kb(not(and(minQuantValue(SUPER,SUPERMIN),quantitySubsumes(SUPER,SUB),minQuantValue(SUB,SUBMIN),greaterThan(SUPERMIN,SUBMIN))),iBaseKB,vStrDef).
tiny_kb(not(and(minQuantValue(INTERVAL1,MIN1),quantityIntersects(INTERVAL1,INTERVAL2),maxQuantValue(INTERVAL2,MAX2),greaterThan(MIN1,MAX2))),iBaseKB,vStrDef).
tiny_kb(not(and(microtheoryDesignationArgnum(RELN,NUM),sentenceDesignationArgnum(RELN,NUM))),iBaseKB,vStrDef).
tiny_kb(not(and(rtPartiallyCommutativeRelation(REL),arity(REL,5),different(J,K,L,M,N),commutativeInArgs(REL,J,K,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(rtPartiallyCommutativeRelation(REL),arity(REL,4),different(K,L,M,N),commutativeInArgs(REL,K,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(rtPartiallyCommutativeRelation(REL),arity(REL,3),different(L,M,N),commutativeInArgs(REL,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(rtPartiallyCommutativeRelation(REL),arity(REL,2),different(M,N),commutativeInArgs(REL,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(rtAntiTransitiveBinaryPredicate(PRED),rtTransitiveBinaryPredicate(PRED),t(PRED,_A,B),t(PRED,B,_C))),iBaseKB,vStrDef).
tiny_kb(not(and(rtAntiTransitiveBinaryPredicate(PRED),t(PRED,X,Y),t(PRED,X,Z),t(PRED,Y,Z))),iBaseKB,vStrDef).
tiny_kb(not(and(rtAntiSymmetricBinaryPredicate(PRED),admittedArgument(ARG1,1,PRED),admittedArgument(ARG1,2,PRED),different(ARG1,ARG2),t(PRED,ARG2,ARG1),t(PRED,ARG1,ARG2),admittedArgument(ARG2,1,PRED),admittedArgument(ARG2,2,PRED))),iBaseKB,vStrDef).
tiny_kb(not(and(isa(OBJ,COL1),isa(OBJ,COL2),genls(COL2,COL3),disjointWith(COL1,COL3))),iBaseKB,vStrDef).
tiny_kb(not(and(isa(INST1,TYPE1),isa(INST2,TYPE2),t(PRED,INST1,INST2),relationAllExistsCount(PRED,TYPE1,TYPE2,0))),iBaseKB,vStrDef).
tiny_kb(not(and(holdsIn(TIME,PROP),holdsIn(TIME,not(PROP)))),iBaseKB,vStrDef).
tiny_kb(not(and(greaterThan(INTERVAL1,INTERVAL2),quantityIntersects(INTERVAL1,INTERVAL2))),iBaseKB,vStrDef).
tiny_kb(not(and(different(THING1,THING2),equals(THING1,THING2))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,5),different(J,K,L,M,N),commutativeInArgsAndRest(REL,J,K,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,4),different(K,L,M,N),commutativeInArgsAndRest(REL,K,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,3),different(L,M,N),commutativeInArgsAndRest(REL,L,M,N))),iBaseKB,vStrDef).
tiny_kb(not(and(arity(REL,2),different(M,N),commutativeInArgsAndRest(REL,M,N))),iBaseKB,vStrDef).
tiny_kb(argFormat(myCreator,2,vSingleEntry),iBookkeepingMt,vStrMon).
tiny_kb(argFormat(myCreationTime,2,vSingleEntry),iBookkeepingMt,vStrMon).
tiny_kb(argFormat(myCreationSecond,2,vSingleEntry),iBookkeepingMt,vStrMon).
tiny_kb(argFormat(myCreationTime,1,vSetTheFormat),iBookkeepingMt,vStrMon).
tiny_kb(oldConstantName(commutativeInArgs,"symmetricInArgs"),iBookkeepingMt,vStrMon).
tiny_kb(comment(oldConstantName,"This bookkeeping predicate relates a CycL constant to a former \"name\" of that constant.  More accurately, (oldConstantName CONSTANT STRING) means that the underlying data structure currently associated with the CycL expression CONSTANT was formerly associated instead with the SubL string STRING.  If CONSTANT has undergone multiple \"renames\", STRING will \nnormally be its most recent former \"name\".  While oldConstantName sentences \ncan be asserted and edited by hand, they are asserted automatically when a Rename is done in the Knowledge Base."),iBookkeepingMt,vStrMon).
tiny_kb(comment(myCreationSecond,"(myCreationSecond CONSTANT SECOND) means that the CycLConstant CONSTANT was created at the CycUniversalSecond SECOND on the day CONSTANT was created (the related predicate myCreationTime (q.v.) relates a CycLConstant to the day it was created).  The format of SECOND is HHMMSS; that is, the first two digits give the hour of the day on which the constant was created, the second two digits give the minute of the hour at which the constant was created, and the last two digits give the second of the minute at which the constant was created.  For example, midnight is 000000 (or simply 0), noon is 120000, 3:42:59 pm is 154259, and 11:59:59 pm is 235959."),iBookkeepingMt,vStrMon).
tiny_kb(comment(myCreationPurpose,"A BookkeepingPredicate and a DocumentationConstant that relates a CycL constant (or other reifiable denotational term) to the Cyc-based project for which the term was created.  (myCreationPurpose TERM PROJECT) means that TERM was created as part of work that was done for PROJECT, and implies that the creator of TERM (see myCreator) was working PROJECT at the time."),iBookkeepingMt,vStrMon).
tiny_kb(comment(argAndRestQuotedIsa,"A ternary ArgQuotedIsaPredicate (q.v.) used to place a specified quoted isa based argument-type constraint on a given VariableArityRelation (q.v.) with respect to any of its argument-places whose ordinal position is greater than or equal to a specified number. (argAndRestQuotedIsa RELN N COL) means that, as a necessary condition for semantic well-formedness, anything given as the Nth or greater argument to RELN must be a quoted instance of COL. Thus a closed formula (RELN ARG1..ARG(N)..ARG(N+1)..) is well-formed only if each of ARG(N)..ARG(N+1).. is a quoted instance of COL. See also argsQuotedIsa."),iBookkeepingMt,vStrMon).
tiny_kb(notAssertibleCollection(vtCanonicalizerDirective),iBookkeepingMt,vStrMon).
tiny_kb(completeExtentEnumerable(myCreator),iBookkeepingMt,vStrMon).
tiny_kb(completeExtentEnumerable(myCreationTime),iBookkeepingMt,vStrMon).
tiny_kb(completeExtentEnumerable(myCreationSecond),iBookkeepingMt,vStrMon).
tiny_kb(argQuotedIsa(oldConstantName,2,ftString),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(oldConstantName,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreator,1,ftReifiableDenotationalTerm),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationTime,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationSecond,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationPurpose,1,ftReifiableDenotationalTerm),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(oldConstantName,2,ftString),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(oldConstantName,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreator,2,mobCyclist),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreator,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationTime,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationSecond,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationPurpose,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(oldConstantName,2,ftString),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(oldConstantName,2,ftString),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreator,2,mobCyclist),iBookkeepingMt,vStrDef).
tiny_kb(argFormat(myCreationPurpose,2,singleEntryFormatInArgs),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(oldConstantName,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreator,1,ftReifiableDenotationalTerm),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationTime,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationSecond,1,ftConstant),iBookkeepingMt,vStrDef).
tiny_kb(argQuotedIsa(myCreationPurpose,1,ftReifiableDenotationalTerm),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(oldConstantName,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreator,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationTime,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationSecond,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argIsa(myCreationPurpose,1,tThing),iBookkeepingMt,vStrDef).
tiny_kb(argFormat(myCreationPurpose,1,openEntryFormatInArgs),iBookkeepingMt,vStrDef).
tiny_kb(singleEntryFormatInArgs(myCreationPurpose,2),iBookkeepingMt,vStrDef).
tiny_kb(openEntryFormatInArgs(myCreationPurpose,1),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(unknownSentence,"unknownFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(trueSentence,"trueFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(exists,"ThereExists"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(thereExistExactly,"ThereExistExactly"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(thereExistAtMost,"ThereExistAtMost"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(thereExistAtLeast,"ThereExistAtLeast"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(sentenceImplies,"formulaImplies"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(sentenceEquiv,"formulaEquiv"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(sentenceDesignationArgnum,"formulaDesignationArgnum"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(resultIsa,"resultType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(resultGenl,"usesAreSpecsOf"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(relationAllExistsCount,"relationTypeCount"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(pragmaticRequirement,"pragmaticImplies"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(or,"LogOr"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(numericallyEquals,"numericallyEqual"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(not,"LogNot"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(knownSentence,"knownFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(isa,"instanceOf"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(interArgResultGenl,"interArgResultGenls"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(implies,"LogImplication"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(genlMt,"baseMt"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(all,"ForAll"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(except,"exceptedAssertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(evaluationDefn,"lispDefun"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(equalSymbols,s("equals","-","Symbols")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(disjointWith,"mutuallyDisjointWith"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(differentSymbols,s("different","-","Symbols")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(defnSufficient,"defn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(defnIff,"necessaryDefn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(conceptuallyRelated,"mysteryLink"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(completelyEnumerableCollection,"completeCollectionExtent"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(completeExtentEnumerableForValueInArg,"completeExtentKnownForArg"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(completeExtentEnumerable,"completeExtentKnown"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(comment,"english"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(collectionCompletelyEnumerableViaBackchain,"collectionCompletelyEnumerableViaBackchains"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(assertedTermSentences,"assertedTermFormulas"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(call_u_no_bc,"assertedFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arity,"expressionArity"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(argsIsa,"argumentTypes"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg5Isa,"argumentFiveType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg4Isa,"argumentFourType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg3Isa,"argumentThreeType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg3Genl,"argumentThreeGenls"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg2Isa,"argumentTwoType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg2Genl,"argumentTwoGenls"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg1Isa,"argumentOneType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(arg1Genl,"argumentOneGenls"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(and,"LogAnd"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(admittedSentence,"admittedFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vUnknownHLTruthValue,s("Unknown","-","TruthValue")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(rtTransitiveBinaryPredicate,"TransitiveSlot"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vTimesFn,"Times"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSymbol,"LispSymbol"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSymbol,"CycSystemSymbol"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftString,"CycSystemString"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSubLSExpression,"SubLExpression"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftRealNumber,"LispRealNumber"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftRealNumber,"CycSystemRealNumber"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftList,"CycSystemList"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftKeyword,"CycSystemKeyword"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftInt,"CycSystemInteger"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftAtom,"LispAtom"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftAtom,"CycSystemAtom"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ttSiblingDisjointAttributeType,"MutuallyDisjointAttributeType"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(rtSententialRelation,"NonPredicateTruthFunction"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tRelation,"Relationship"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vQuotientFn,"Quotient"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vPlusFn,"Plus"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(mtMtTimeWithGranularityDimFn,"MtTimeDimWithGranularityFn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(iLogicalTruthImplementationMt,"CycInferenceMt"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vLogFn,"Log"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftList,"List"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vLeaveSomeTermsAtELAndAllowKeywordVariables,"CanonicalizeForNL"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vIntervalMinFn,"IntervalMin"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vIntervalMaxFn,"IntervalMax"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(iInferencePSC,"ForwardInferencePSC"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tHLAssertedArgumentKeywordDatastructure,"HLAssertedArgumentKeyword"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vFormulaArityFn,"RelationExpressionArityFn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tSetOfFormulaArgSetFn,"RelationArgSetFn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vFormulaArgListFn,"RelationArgsListFn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(uFormulaArgFn,"RelationArgFn"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vExpFn,"Exp"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(rtExceptionPredicate,"ExceptionRelation"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(rtEvaluatableRelation,"EvaluatableRelationship"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(equalStringsCaseinsensitive,s("equals","-","CaseInsensitive")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(iELRelationReversible,s("ELRelation","-","SemiReversible")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vDifferenceFn,"Difference"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tCycSupportDatastructure,"CycLSupportDatastructure"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftExpression,"CycTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSentence,"CycSyntacticFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSentence,"ConstraintLanguageExpression"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftRuleAssertion,"RuleAssertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftReifiableNonAtomicTerm,"ReifiableNAT"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftReifiableDenotationalTerm,"ReifiableTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftCycLOpenExpression,"CycOpenTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftNonAtomicTerm,"NonAtomicTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftIndexedTerm,"CycIndexedTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftGAFAssertion,"GAFAssertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftSentence,"RelationExpression"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftDeducedAssertion,"DeducedAssertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftConstant,"CycConstant"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftCycLClosedExpression,"CycClosedTerm"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftAtomicSentence,"CycAtomicFormula"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftAssertion,"Assertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftAssertedAssertion,"AssertedAssertion"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(ftKBDatastructure,"CycLKBDatastructure"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vtHLTruthValue,"CyclTruthValue"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tCycDeductionDatastructure,"CycLDeductionDatastructure"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(tCycArgumentDatastructure,"CycLArgumentDatastructure"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(iCurrentWorldDataCollectorMtNonHomocentric,s("CurrentWorldDataCollectorMtt","-","NonHomocentric")),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(rtArgGenlQuantityBinaryPredicate,"ArgGenlQuanityBinaryPredicate"),iBookkeepingMt,vStrDef).
tiny_kb(oldConstantName(vAbsoluteValueFn,"AbsoluteValue"),iBookkeepingMt,vStrDef).
tiny_kb(comment(myCreator,"(myCreator X Y) means that Y is the constant representing the person who introduced the constant X into the Cyc vocabulary. In general, the editing interfaces to the Cyc KB only allow the KB to be modified when an instance of Cyclist is designated as the author of the changes.  See also sourceOfTerm-Person."),iBookkeepingMt,vStrDef).
tiny_kb(comment(myCreationTime,"(myCreationTime CONSTANT TIME) means that the CycLConstant CONSTANT was created at TIME, an instance of CycUniversalDate.  The format of TIME is YYYYMMDD; that is, the first four digits give the year in which the constant was created, the next two digits give the month in which it was created, and the final two digits give the day of the month on which it was created. For example, 19910309 is March 9, 1991."),iBookkeepingMt,vStrDef).
tiny_kb(implies(call_u_no_bc(relationAllInstance(quotedIsa,COLL,QUOTED_COLL)),meetsPragmaticRequirement(vTheListFn(INS,COLL,QUOTED_COLL),'TINYKB-ASSERTION'(':TRUE-DEF',[[[isa,INS,COLL],[relationAllInstance,quotedIsa,COLL,QUOTED_COLL]],[[quotedIsa,INS,QUOTED_COLL]]],iBookkeepingMt,s("?INS","?COLL","?QUOTED-COLL"),[implies,[and,[isa,INS,COLL],[relationAllInstance,quotedIsa,COLL,QUOTED_COLL]],[quotedIsa,INS,QUOTED_COLL]]))),iBookkeepingMt,vStrDef).
tiny_kb(implies(and(isa(INS,COLL),relationAllInstance(quotedIsa,COLL,QUOTED_COLL)),quotedIsa(INS,QUOTED_COLL)),iBookkeepingMt,vStrDef).
tiny_kb(backchainForbidden(myCreator),iBookkeepingMt,vStrDef).
tiny_kb(backchainForbidden(myCreationTime),iBookkeepingMt,vStrDef).
tiny_kb(backchainForbidden(myCreationSecond),iBookkeepingMt,vStrDef).
tiny_kb(genFormat(xor,s("either","~a","or","~a","(","but","not","both",")"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(trueRule,s("~a","is","true",",","and","~a","is","an","instantiation","of","the","rule","template","~a"),vTheListFn(2,2,1)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(thereExistAtMost,s("there","~a","at","most","~a","~a","such","that","~a"),vTheListFn(vTheListFn("is","are"),1,2,3)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(thereExistAtLeast,s("there","~a","at","least","~a","~a","such","that","~a"),vTheListFn(vTheListFn("is","are"),1,2,3)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(synonymousExternalConcept,s("~s","is","synonymous","with","~s","in","~a"),vTheListFn(vTheListFn(1,':SINGULAR'),3,2)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(substring,s("~s","is","a","substring","of","~s"),vTheListFn(1,2)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(sentenceEquiv,s("the","formula","~a","is","logically","equivalent","to","the","formula","~a"),vTheListFn(vTheListFn(1,':QUOTE'),vTheListFn(2,':QUOTE'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(requiredArg2Pred,s("every","~a","is","arg","2","of","~a","relation"),vTheListFn(1,vTheListFn(2,':QUOTE',':A_THE_WORD'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(relationExpansion,s("one","CycL","expansion","for","assertions","which","have","~a","in","the","operator","position","is","~a"),vTheListFn(vTheListFn(1,':EQUALS'),vTheListFn(2,':EQUALS'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(notAssertibleMt,s("Sentences","cannot","be","asserted","in","~a"),vTheListFn(vTheListFn(1,':EQUALS'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(nearestCommonIsa,s("both","~a","and","~a","are","~a"),vTheListFn(1,2,vTheListFn(3,vTheListFn(':PN_MASS_NUMBER',':PN_SINGULAR',':MASS_NUMBER'),':GERUND',':AGENTIVE_SG',':SINGULAR',':A_THE_WORD'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(indexicalReferent,s("the","indexical","term","~a","refers","to","~a"),vTheListFn(vTheListFn(1,':QUOTE'),2)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(implies,s("if","~a",",","then","~a"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(genFormat,s("to","generate","English","for","assertions","formed","with","~a",",","the","format","string","~a","is","used","with","the","extra","information","in","this","list",":","~a"),vTheListFn(vTheListFn(1,':EQUALS'),2,3)),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(all,s("for","every","~a",",","~a"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(equiv,s("~a","if","and","only","if","~a"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(differentSymbols,s("~a","are","different","symbols"),vTheListFn(vTheListFn(1,':AND'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycTacticID,s("the","inference","tactic","~a","contained","within","the","inference","problem","~a",",","has","~a","as","its","ID"),vTheListFn(vTheListFn(1,':SINGULAR'),vTheListFn(2,':SINGULAR'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProofID,s("the","inference","proof","~a","contained","within","inference","problem","store","~a",",","has","~a","as","its","ID"),vTheListFn(vTheListFn(1,':SINGULAR'),vTheListFn(2,':SINGULAR'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemStoreProofCount,s("the","inference","problem","store","~a","has","~a","proof","~a"),vTheListFn(1,2,vTheListFn("","s"))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemStoreProblemCount,s("the","inference","problem","store","~a","has","~a","inference","problem","~a"),vTheListFn(1,2,vTheListFn("","s"))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemStoreLinkCount,s("the","inference","problem","store","~a","has","~a","inference","link","~a"),vTheListFn(1,2,vTheListFn("","s"))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemStoreInferenceCount,s("the","inference","problem","store","~a","has","~a","inference","~a"),vTheListFn(1,2,vTheListFn("","s"))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemLinkID,s("the","inference","problem","link","~a","contained","within","inference","problem","store","~a",",","has","~a","as","its","ID"),vTheListFn(vTheListFn(1,':SINGULAR'),vTheListFn(2,':SINGULAR'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycProblemID,s("the","inference","problem","~a","contained","within","inference","problem","store","~a",",","has","~a","as","its","ID"),vTheListFn(vTheListFn(1,':SINGULAR'),vTheListFn(2,':SINGULAR'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(completeExtentEnumerable,s("the","complete","extent","of","the","predicate","~a","is","known"),vTheListFn(vTheListFn(1,':EQUALS'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(cycUnitProductFn,s("~a","-","~a"),vTheListFn(vTheListFn(1,':PLURAL'),vTheListFn(2,':SINGULAR'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(tSetOfTheSetFn,s("the","set","containing","~a"),vTheListFn(vTheListFn(1,':AND'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(substringCaseinsensitive,s("~s","is","a","case","-","insensitive","substring","of","~s"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vRoundUpFn,s("~a",",","truncated"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vRoundUpFn,s("~a",",","rounded","up"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vRoundDownFn,s("~a",",","rounded","down"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vPlusFn,s("the","sum","of","~a"),vTheListFn(vTheListFn(1,':AND'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vPlusAllFn,s("the","sum","of","~a","over","~a"),vTheListFn(2,vTheListFn(1,':PLURAL'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vMinRangeFn,s("the","minimum","range","subsumed","by","~a","and","~a"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vMinimumFn,s("the","minimum","~a","over","~a"),vTheListFn(2,vTheListFn(1,':PLURAL'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vMaxRangeFn,s("the","maximum","range","subsuming","~a","and","~a"),vTheEmptyList),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(vMaximumFn,s("the","maximum","~a","over","~a"),vTheListFn(2,vTheListFn(1,':PLURAL'))),iEnglishParaphraseMt,vStrDef).
tiny_kb(genFormat(iFunctionToArgFn,s("'","~a","'"),vTheListFn(2,':SINGULAR',':MASS_NUMBER')),iEnglishParaphraseMt,vStrDef).
tiny_kb(requiredArg1Pred(tRelation,genFormat),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(exists,':THERE_EXISTS'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(thereExistExactly,':THERE_EXIST_EXACTLY'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(thereExistAtMost,':THERE_EXIST_AT_MOST'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(thereExistAtLeast,':THERE_EXIST_AT_LEAST'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(termOfUnit,':TERM_OF_UNIT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(relationExpansion,':RELATION_EXPANSION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(prettyString,':PRETTY_NAME'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(or,':OR'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(nthSmallestElement,':NTH_SMALLEST_ELEMENT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(nthLargestElement,':NTH_LARGEST_ELEMENT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(not,':NOT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(myCreator,':MY_CREATOR'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(myCreationTime,':MY_CREATION_TIME'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(isa,':ISA'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(implies,':IMPLIES'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(genMassNoun,':GEN_MASS_NOUN'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(genls,':GENLS'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(genFormat,':GEN_FORMAT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(all,':FOR_ALL'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(exceptWhen,':EXCEPT_WHEN'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(exceptFor,':EXCEPT_FOR'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(equals,':EQUALS'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(different,':DIFFERENT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(and,':AND'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(rtVariableArityRelation,':VARIABLE_ARITY_RELATION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(ttUnitOfMeasure,':UNIT_OF_MEASURE'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tThing,':THING'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(ftTheTerm,':THE_TERM'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(ttSetOrCollection,':SET_OR_COLLECTION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tSetMathematical,':SET_MATHEMATICAL'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vSeptember,':SEPTEMBER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tRelation,':RELATIONSHIP'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(rtQuantifier,':QUANTIFIER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(cycPerFn,':PER_FN'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vOctober,':OCTOBER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vNovember,':NOVEMBER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(ftNonNegativeInteger,':NON_NEGATIVE_INTEGER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(iMeaningInSystemFn,':MEANING_IN_SYSTEM_FN'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vMay,':MAY'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vMarch,':MARCH'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(rtLogicalConnective,':LOGICAL_CONNECTIVE'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(iKappaFn,':KAPPA'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vJune,':JUNE'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vJuly,':JULY'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vJanuary,':JANUARY'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tIndividual,':INDIVIDUAL'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(iFunctionToArgFn,':FUNCTION_TO_ARG'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tFunction,':NON_PREDICATE_FUNCTION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(rtFixedAritySkolemFunction,':SKOLEM_FUNCTION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vFebruary,':FEBRUARY'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(iEnglishParaphraseMt,':ENGLISH_PARAPHRASE_MT'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vDecember,':DECEMBER'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(tCol,':COLLECTION'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(iBaseKB,':BASE_K_B'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vAugust,':AUGUST'),iEnglishParaphraseMt,vStrDef).
tiny_kb(genKeyword(vApril,':APRIL'),iEnglishParaphraseMt,vStrDef).