//  -*- Mode: Java -*-
//
// _StartupLogicIn.java

/*
 +---------------------------- BEGIN LICENSE BLOCK ---------------------------+
 |                                                                            |
 | Version: MPL 1.1/GPL 2.0/LGPL 2.1                                          |
 |                                                                            |
 | The contents of this file are subject to the Mozilla Public License        |
 | Version 1.1 (the "License"); you may not use this file except in           |
 | compliance with the License. You may obtain a copy of the License at       |
 | http://www.mozilla.org/MPL/                                                |
 |                                                                            |
 | Software distributed under the License is distributed on an "AS IS" basis, |
 | WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License   |
 | for the specific language governing rights and limitations under the       |
 | License.                                                                   |
 |                                                                            |
 | The Original Code is the PowerLoom KR&R System.                            |
 |                                                                            |
 | The Initial Developer of the Original Code is                              |
 | UNIVERSITY OF SOUTHERN CALIFORNIA, INFORMATION SCIENCES INSTITUTE          |
 | 4676 Admiralty Way, Marina Del Rey, California 90292, U.S.A.               |
 |                                                                            |
 | Portions created by the Initial Developer are Copyright (C) 1997-2017      |
 | the Initial Developer. All Rights Reserved.                                |
 |                                                                            |
 | Contributor(s):                                                            |
 |                                                                            |
 | Alternatively, the contents of this file may be used under the terms of    |
 | either the GNU General Public License Version 2 or later (the "GPL"), or   |
 | the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),   |
 | in which case the provisions of the GPL or the LGPL are applicable instead |
 | of those above. If you wish to allow use of your version of this file only |
 | under the terms of either the GPL or the LGPL, and not to allow others to  |
 | use your version of this file under the terms of the MPL, indicate your    |
 | decision by deleting the provisions above and replace them with the notice |
 | and other provisions required by the GPL or the LGPL. If you do not delete |
 | the provisions above, a recipient may use your version of this file under  |
 | the terms of any one of the MPL, the GPL or the LGPL.                      |
 |                                                                            |
 +----------------------------- END LICENSE BLOCK ----------------------------+
*/

package edu.isi.powerloom.logic;

import edu.isi.stella.javalib.Native;
import edu.isi.stella.javalib.StellaSpecialVariable;
import edu.isi.stella.*;

public class _StartupLogicIn {
  static void helpStartupLogicIn1() {
    {
      Logic.KWD_TRACE_CLASSIFIER = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("TRACE-CLASSIFIER", null, 2)));
      Logic.KWD_ITERATIVE_DEEPENING = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("ITERATIVE-DEEPENING", null, 2)));
      Logic.KWD_JUST_IN_TIME_INFERENCE = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("JUST-IN-TIME-INFERENCE", null, 2)));
      Logic.KWD_EMIT_THINKING_DOTS = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("EMIT-THINKING-DOTS", null, 2)));
      Logic.KWD_CLOSED_WORLD = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("CLOSED-WORLD", null, 2)));
      Logic.KWD_BYE = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("BYE", null, 2)));
      Logic.KWD_EXIT = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("EXIT", null, 2)));
      Logic.KWD_HALT = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("HALT", null, 2)));
      Logic.KWD_QUIT = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("QUIT", null, 2)));
      Logic.KWD_STOP = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("STOP", null, 2)));
      Logic.KWD_DEFINE = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFINE", null, 2)));
      Logic.SYM_STELLA_DEFMODULE = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFMODULE", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.KWD_FINALIZE = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("FINALIZE", null, 2)));
      Logic.KWD_CHECK_DUPLICATESp = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("CHECK-DUPLICATES?", null, 2)));
      Logic.SYM_STELLA_CLEAR_MODULE = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("CLEAR-MODULE", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_DEFCLASS = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFCLASS", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_DEFSLOT = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFSLOT", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_DEFMETHOD = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFMETHOD", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_LOGIC_DEFCONCEPT = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFCONCEPT", null, 0)));
      Logic.SYM_LOGIC_DEFFUNCTION = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFFUNCTION", null, 0)));
      Logic.SYM_LOGIC_DEFOBJECT = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFOBJECT", null, 0)));
      Logic.SYM_LOGIC_DEFINSTANCE = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFINSTANCE", null, 0)));
      Logic.KWD_LOW = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("LOW", null, 2)));
      Logic.KWD_WHITE_SPACE = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("WHITE-SPACE", null, 2)));
      Logic.KWD_LEVEL = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("LEVEL", null, 2)));
      Logic.KWD_PORT = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("PORT", null, 2)));
      Logic.KWD_HOST = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("HOST", null, 2)));
      Logic.KWD_DEBUG_LEVEL = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("DEBUG-LEVEL", null, 2)));
      Logic.SYM_LOGIC_POWERLOOM_GUI_EXIT_HOOK = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("POWERLOOM-GUI-EXIT-HOOK", null, 0)));
      Logic.SYM_LOGIC_MODULE_LOGIC_DIALECT = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("MODULE-LOGIC-DIALECT", null, 0)));
      Logic.KWD_REDEFINITION = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("REDEFINITION", null, 2)));
      Logic.KWD_PROPER_DEFINITION = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("PROPER-DEFINITION", null, 2)));
      Logic.SYM_LOGIC_OBJECT_AXIOMS = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("OBJECT-AXIOMS", null, 0)));
      Logic.SYM_LOGIC_PROPOSITION_AXIOMS = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("PROPOSITION-AXIOMS", null, 0)));
      Logic.SYM_STELLA_SLOT_OPTION_KEYWORD = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("SLOT-OPTION-KEYWORD", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_PL_KERNEL_KB_NTH_DOMAIN = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("NTH-DOMAIN", Stella.getStellaModule("/PL-KERNEL-KB", true), 0)));
      Logic.SYM_PL_KERNEL_KB_DOMAIN = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DOMAIN", Stella.getStellaModule("/PL-KERNEL-KB", true), 0)));
      Logic.SYM_PL_KERNEL_KB_RANGE = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("RANGE", Stella.getStellaModule("/PL-KERNEL-KB", true), 0)));
      Logic.KWD__g = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("->", null, 2)));
      Logic.SYM_LOGIC_pSELF = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("?SELF", null, 0)));
      Logic.KWD_eg = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("=>", null, 2)));
      Logic.SYM_LOGIC_DEFPROPOSITION = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DEFPROPOSITION", null, 0)));
      Logic.KWD_FORWARDp = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("FORWARD?", null, 2)));
      Logic.KWD_FORWARD_ONLYp = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("FORWARD-ONLY?", null, 2)));
      Logic.KWD_BACKWARDp = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("BACKWARD?", null, 2)));
      Logic.KWD_BACKWARD_ONLYp = ((Keyword)(GeneralizedSymbol.internRigidSymbolWrtModule("BACKWARD-ONLY?", null, 2)));
      Logic.SYM_STELLA_CC = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("CC", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_IN_MODULE = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("IN-MODULE", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_LIST_MODULES = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("LIST-MODULES", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_METHOD_COMMANDp = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("METHOD-COMMAND?", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_STELLA_DOCUMENTATION = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("DOCUMENTATION", Stella.getStellaModule("/STELLA", true), 0)));
      Logic.SYM_LOGIC_STARTUP_LOGIC_IN = ((Symbol)(GeneralizedSymbol.internRigidSymbolWrtModule("STARTUP-LOGIC-IN", null, 0)));
    }
  }

  static void helpStartupLogicIn2() {
    {
      Logic.$AVAILABLE_POWERLOOM_FEATURES$ = List.list(Cons.cons(Logic.KWD_TRACE_SUBGOALS, Cons.cons(Logic.KWD_TRACE_SOLUTIONS, Cons.cons(Logic.KWD_TRACE_CLASSIFIER, Cons.cons(Logic.KWD_ITERATIVE_DEEPENING, Cons.cons(Logic.KWD_JUSTIFICATIONS, Cons.cons(Logic.KWD_JUST_IN_TIME_INFERENCE, Cons.cons(Logic.KWD_EMIT_THINKING_DOTS, Stella.NIL))))))));
      Logic.$CURRENT_POWERLOOM_FEATURES$ = List.list(Stella.NIL);
      Logic.$DEFAULT_POWERLOOM_FEATURES$ = List.list(Cons.cons(Logic.KWD_JUST_IN_TIME_INFERENCE, Cons.cons(Logic.KWD_EMIT_THINKING_DOTS, Stella.NIL)));
      Logic.resetFeatures();
      Logic.$PROMPT_SHOW_MODULEp$.setDefaultValue(new Boolean(true));
      Logic.$CAREFUL_LOGIC_COMMAND_LOOP_EXIT$p.setDefaultValue(new Boolean(true));
      Logic.$POWERLOOM_KB_FILE_EXTENSIONS$ = Stella.getQuotedTree("((\".plm\" \".ploom\") \"/LOGIC\")", "/LOGIC");
      Logic.$DEMO_LEVEL$.setDefaultValue(new Integer(0));
      Logic.$DEMO_FILES$ = Cons.list$(Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("basics"), Cons.cons(StringWrapper.wrapString("Basic PowerLoom commands"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("classes"), Cons.cons(StringWrapper.wrapString("Primitive and defined classes"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("collections"), Cons.cons(StringWrapper.wrapString("Reasoning with collections"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("append"), Cons.cons(StringWrapper.wrapString("Prolog-style `append'"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("inequalities"), Cons.cons(StringWrapper.wrapString("Reasoning with inequalities"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("recursion"), Cons.cons(StringWrapper.wrapString("Reasoning with recursive rules"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("negation"), Cons.cons(StringWrapper.wrapString("Reasoning with negation"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("constraints"), Cons.cons(StringWrapper.wrapString("Constraint propagation"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("equations"), Cons.cons(StringWrapper.wrapString("Simple equational reasoning"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("subsumption"), Cons.cons(StringWrapper.wrapString("Simple subsumption reasoning"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("family"), Cons.cons(StringWrapper.wrapString("Subsumption reasoning within a family ontology"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("relation-hierarchy"), Cons.cons(StringWrapper.wrapString("Finding sub, super and equivalent concepts and relations"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("defaults"), Cons.cons(StringWrapper.wrapString("Default reasoning with Tweety and friends"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("defaults2"), Cons.cons(StringWrapper.wrapString("More default reasoning"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("definition-syntax"), Cons.cons(StringWrapper.wrapString("The whole scoop on relation definition, funny arrows, etc."), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("meta-relations"), Cons.cons(StringWrapper.wrapString("Using meta-properties and relations"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("partial-match"), Cons.cons(StringWrapper.wrapString("Reasoning with partial information"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("probability-learning"), Cons.cons(StringWrapper.wrapString("Learning to answer probabilistic queries"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("regression-demo"), Cons.cons(StringWrapper.wrapString("Learning to predict functions"), Cons.cons(Stella.NIL, Stella.NIL)))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("rule-induction-demo"), Cons.cons(StringWrapper.wrapString("Learning inference rules"), Cons.cons(Stella.NIL, Stella.NIL)))), Cons.cons(Cons.list$(Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(StringWrapper.wrapString("PowerLoom test suite"), Cons.cons(StringWrapper.wrapString("test-suite"), Cons.cons(Stella.NIL, Stella.NIL))))), Cons.cons(Stella.NIL, Stella.NIL)))))))))))))))))))))));
      Logic.$TERMSOURCEBEINGPARSED$.setDefaultValue(null);
      Logic.$DESCRIPTIONUNDERCONSTRUCTION$.setDefaultValue(null);
      Logic.$TERMUNDERCONSTRUCTION$.setDefaultValue(null);
      Logic.$UNFINALIZED_OBJECTS$ = List.list(Stella.NIL);
      Logic.$FINALIZEOBJECTSIMMEDIATELYp$.setDefaultValue(new Boolean(false));
      Logic.$INHIBITOBJECTFINALIZATIONp$.setDefaultValue(new Boolean(false));
      Logic.$LOGIC_RELEVANT_STELLA_COMMANDS$ = Cons.list$(Cons.cons(Logic.SYM_STELLA_CC, Cons.cons(Logic.SYM_STELLA_CLEAR_MODULE, Cons.cons(Logic.SYM_STELLA_DEFMODULE, Cons.cons(Logic.SYM_STELLA_IN_MODULE, Cons.cons(Logic.SYM_STELLA_LIST_MODULES, Cons.cons(Stella.NIL, Stella.NIL)))))));
    }
  }

  static void helpStartupLogicIn3() {
    {
      Stella.defineFunctionObject("PRINT-FEATURES", "(DEFUN PRINT-FEATURES () :COMMAND? TRUE :PUBLIC? TRUE :DOCUMENTATION \"Print the currently enabled and available PowerLoom environment features.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "printFeatures", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("LIST-FEATURES", "(DEFUN (LIST-FEATURES LIST) () :COMMAND? TRUE :PUBLIC? TRUE :DOCUMENTATION \"Return a list containing two lists, a list of currently enabled PowerLoom\nfeatures, and a list of all available PowerLoom features.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "listFeatures", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("SET-POWERLOOM-FEATURE", "(DEFUN SET-POWERLOOM-FEATURE ((FEATURE KEYWORD)) :DOCUMENTATION \"Enable the PowerLoom environment feature `feature'.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "setPowerloomFeature", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Keyword")}), null);
      Stella.defineFunctionObject("SET-FEATURE", "(DEFUN (SET-FEATURE (LIST OF KEYWORD)) (|&REST| (FEATURES NAME)) :COMMAND? TRUE :PUBLIC? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Enable the PowerLoom environment feature(s) named by `features'.\nReturn the list of enabled features.  Calling `set-feature' without any\narguments can be used to display the currently enabled features.\nThe following features are supported:\n\n`just-in-time-inference': Enables interleaving of forward chaining inference\nwithin backward chaining queries.\n\n`iterative-deepening': Tells the query processor to use iterative deepening\ninstead of a depth-first search to find answers.  This is less efficient\nbut necessary for some kinds of highly recursive queries.\n\n`trace-subgoals': Enables the generation of subgoaling trace information during\nbackchaining inference.\n\n`trace-solutions': Prints newly found solutions during retrieval right when they\nare generated as opposed to when the query terminates.\n\n`trace-classifier': Tells the classifier to describe the inferences it draws.\n\n`justifications': Enables the generation of justifications during inference,\nwhich is a prerequiste for the generation of explanations with `(why)'.\n\n`emit-thinking-dots': Tells PowerLoom to annotate its inference progress by\noutputting characters indicating the completion of individual reasoning steps.\n\nBy default, the features `emit-thinking-dots' and `just-in-time-inference'\nare enabled, and the others are disabled.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "setFeature", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "setFeatureEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("UNSET-POWERLOOM-FEATURE", "(DEFUN UNSET-POWERLOOM-FEATURE ((FEATURE KEYWORD)) :DOCUMENTATION \"Disable the PowerLoom environment feature `feature'.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "unsetPowerloomFeature", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Keyword")}), null);
      Stella.defineFunctionObject("UNSET-FEATURE", "(DEFUN (UNSET-FEATURE (LIST OF KEYWORD)) (|&REST| (FEATURES NAME)) :COMMAND? TRUE :PUBLIC? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Disable the PowerLoom environment feature(s) named by `features'.\nReturn the list of enabled features.  Calling `unset-feature' without any\narguments can be used to display the currently enabled features.\nSee `set-feature' for a description of supported features.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "unsetFeature", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "unsetFeatureEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("RESET-FEATURES", "(DEFUN (RESET-FEATURES (LIST OF KEYWORD)) () :COMMAND? TRUE :PUBLIC? TRUE :DOCUMENTATION \"Reset the PowerLoom environment features to their default settings.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "resetFeatures", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("ENABLED-POWERLOOM-FEATURE?", "(DEFUN (ENABLED-POWERLOOM-FEATURE? BOOLEAN) ((FEATURE KEYWORD)) :DOCUMENTATION \"Return true if the STELLA `feature' is currently enabled.\" :PUBLIC? TRUE :GLOBALLY-INLINE? TRUE (RETURN (MEMB? *CURRENT-POWERLOOM-FEATURES* FEATURE)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "enabledPowerloomFeatureP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Keyword")}), null);
      Stella.defineFunctionObject("DISABLED-POWERLOOM-FEATURE?", "(DEFUN (DISABLED-POWERLOOM-FEATURE? BOOLEAN) ((FEATURE KEYWORD)) :DOCUMENTATION \"Return true if the STELLA `feature' is currently disabled.\" :PUBLIC? TRUE :GLOBALLY-INLINE? TRUE (RETURN (NOT (MEMB? *CURRENT-POWERLOOM-FEATURES* FEATURE))))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "disabledPowerloomFeatureP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Keyword")}), null);
      Stella.defineFunctionObject("PARSE-LOGIC-COMMAND-OPTIONS", "(DEFUN (PARSE-LOGIC-COMMAND-OPTIONS PROPERTY-LIST) ((OPTIONS OBJECT) (|LEGALOPTIONS&TYPES| CONS) (COERCIONERROR? BOOLEAN) (ALLOWOTHERKEYS? BOOLEAN)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "parseLogicCommandOptions", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Cons"), java.lang.Boolean.TYPE, java.lang.Boolean.TYPE}), null);
      Stella.defineFunctionObject("PRINT-LOGIC-PROMPT", "(DEFUN PRINT-LOGIC-PROMPT ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "printLogicPrompt", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("PRINT-LOGIC-COMMAND-RESULT", "(DEFUN PRINT-LOGIC-COMMAND-RESULT ((RESULT OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "printLogicCommandResult", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("LOGIC-COMMAND-LOOP-EXIT?", "(DEFUN (LOGIC-COMMAND-LOOP-EXIT? BOOLEAN BOOLEAN) ((COMMAND OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "logicCommandLoopExitP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("[Ljava.lang.Object;")}), null);
      Stella.defineFunctionObject("LOGIC-COMMAND-LOOP", "(DEFUN LOGIC-COMMAND-LOOP ((MODULE MODULE)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "logicCommandLoop", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Module")}), null);
      Stella.defineFunctionObject("EVALUATE-LOGIC-COMMAND", "(DEFUN (EVALUATE-LOGIC-COMMAND OBJECT) ((COMMAND OBJECT) (FINALIZE? BOOLEAN)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "evaluateLogicCommand", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), java.lang.Boolean.TYPE}), null);
      Stella.defineFunctionObject("LOAD", "(DEFUN LOAD ((FILE STRING) |&REST| (OPTIONS OBJECT)) :DOCUMENTATION \"Read logic commands from `file' and evaluate them.\nBy default, this will check for each asserted proposition whether an\nequivalent proposition already exists and, if so, not assert the\nduplicate.  These duplicate checks are somewhat expensive though and\ncan be skipped by setting the option :check-duplicates? to false.\nThis can save time when loading large KBs where it is known that no\nduplicate assertions exist in a file.\n\nAlso, by setting the option :module, the module in which the file\ncontents will be loaded will be set.  This will only affect files\nthat do NOT have an `in-module' declaration as part of the file.\nIf this is not set, and no `in-module' declaration is in the file,\nthen an error will be signaled.\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "load", new java.lang.Class [] {Native.find_java_class("java.lang.String"), Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("DEFINITION-NAME?", "(DEFUN (DEFINITION-NAME? BOOLEAN) ((NAME SYMBOL)) :PUBLIC? FALSE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "definitionNameP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol")}), null);
      Stella.defineFunctionObject("LOAD-STREAM", "(DEFUN LOAD-STREAM ((STREAM INPUT-STREAM)) :DOCUMENTATION \"Read logic commands from `stream' and evaluate them.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadStream", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.InputStream")}), null);
      Stella.defineFunctionObject("LOAD-STREAM-IN-MODULE", "(DEFUN LOAD-STREAM-IN-MODULE ((STREAM INPUT-STREAM) (DEFAULT-MODULE MODULE)) :DOCUMENTATION \"Read logic commands from `stream' and evaluate them.  If `default-module'\nis not `null', then any commands will be read into that module unless\nan `in-module' declaration is encountered which will over-ride the default\nvalue.  If noe `default-module' is specified, and the input stream does\nnot have an `in-module' form, an error is signaled.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadStreamInModule", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.InputStream"), Native.find_java_class("edu.isi.stella.Module")}), null);
      Stella.defineFunctionObject("LOAD-DIRECTORY", "(DEFUN LOAD-DIRECTORY ((DIRECTORY STRING)) :DOCUMENTATION \"Load all PowerLoom files (*.plm) in `directory' in alphabetic sort order.\" :PUBLIC? TRUE :COMMAND? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadDirectory", new java.lang.Class [] {Native.find_java_class("java.lang.String")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadDirectoryEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("LOAD-CMD-LINE-FILES", "(DEFUN LOAD-CMD-LINE-FILES () :DOCUMENTATION \"Loads all PowerLoom files specified on the command line.\nIf directories are listed, all PowerLoom files in those directories are loaded.\nSince when this is called we might still have unprocessed command line args,\nthis only looks at files which are to the right of the last argument that\nstarts with a `-' character.\" :PUBLIC? TRUE :COMMAND? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "loadCmdLineFiles", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("PRINT-DEMO-PROMPT", "(DEFUN PRINT-DEMO-PROMPT ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "printDemoPrompt", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("DEMO-SKIP-TO-COMMAND", "(DEFUN (DEMO-SKIP-TO-COMMAND BOOLEAN) ((STREAM INPUT-STREAM)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoSkipToCommand", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.InputStream")}), null);
      Stella.defineFunctionObject("DEMO-PAUSE?", "(DEFUN (DEMO-PAUSE? BOOLEAN BOOLEAN) ((PAUSE? BOOLEAN)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoPauseP", new java.lang.Class [] {java.lang.Boolean.TYPE, Native.find_java_class("[Ljava.lang.Object;")}), null);
      Stella.defineFunctionObject("DEMO-FILE", "(DEFUN DEMO-FILE ((FILE FILE-NAME) (PAUSE? BOOLEAN)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoFile", new java.lang.Class [] {Native.find_java_class("java.lang.String"), java.lang.Boolean.TYPE}), null);
      Stella.defineFunctionObject("DEMO-ENTRY-FILE", "(DEFUN (DEMO-ENTRY-FILE STRING) ((DEMOENTRY (CONS OF STRING-WRAPPER))))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoEntryFile", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEMO-ENTRY-DESCRIPTION", "(DEFUN (DEMO-ENTRY-DESCRIPTION STRING) ((DEMOENTRY (CONS OF STRING-WRAPPER))))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoEntryDescription", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEMO-ENTRY-TEST-SUITE?", "(DEFUN (DEMO-ENTRY-TEST-SUITE? BOOLEAN) ((DEMOENTRY (CONS OF STRING-WRAPPER))))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoEntryTestSuiteP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("SELECT-EXAMPLE-DEMO", "(DEFUN (SELECT-EXAMPLE-DEMO STRING) ((INDEX INTEGER)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "selectExampleDemo", new java.lang.Class [] {java.lang.Integer.TYPE}), null);
      Stella.defineFunctionObject("SELECT-EXAMPLE-DEMO-FROM-MENU", "(DEFUN (SELECT-EXAMPLE-DEMO-FROM-MENU STRING) ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "selectExampleDemoFromMenu", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("DEMO-EXAMPLE-DEMOS", "(DEFUN DEMO-EXAMPLE-DEMOS ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoExampleDemos", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("DEMO", "(DEFUN DEMO (|&REST| (FILEANDPAUSE OBJECT)) :COMMAND? TRUE :PUBLIC? TRUE :EVALUATE-ARGUMENTS? TRUE :DOCUMENTATION \"Read logic commands from a file, echo them verbatimly to standard output,\nand evaluate them just as if they had been typed in interactively.\nWhen called with no arguments, present a menu of example demos, otherwise,\nuse the first argument as the name of the file to demo.\nPause for user confirmation after each expression has been read but\nbefore it is evaluated.  Pausing can be turned off by suppling FALSE\nas the optional second argument, or by typing `c' at the pause prompt.\nTyping `?' at the pause prompt prints a list of available commands.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "demo", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "demoEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("TEST-LOGIC-FILE", "(DEFUN TEST-LOGIC-FILE ((FILE FILE-NAME)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "testLogicFile", new java.lang.Class [] {Native.find_java_class("java.lang.String")}), null);
      Stella.defineFunctionObject("GET-FORMATTED-DATE-AND-TIME", "(DEFUN (GET-FORMATTED-DATE-AND-TIME STRING) ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "getFormattedDateAndTime", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("RUN-POWERLOOM-TESTS", "(DEFUN RUN-POWERLOOM-TESTS () :COMMAND? TRUE :PUBLIC? TRUE :DOCUMENTATION \"Run the PowerLoom test suite.  Currently this simply runs all demos and\nechos commands and their results to standard output.  The output can then\nbe diffed with previously validated runs to find deviations.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "runPowerloomTests", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("TIME-COMMAND", "(DEFUN (TIME-COMMAND OBJECT) ((COMMAND CONS)) :DOCUMENTATION \"Execute `command', measure and report its CPU and elapsed time\nneeded for its execution, and then return its result.\" :COMMAND? TRUE :PUBLIC? TRUE :EVALUATE-ARGUMENTS? FALSE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "timeCommand", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("GET-HTTP-SERVER-SYSTEM", "(DEFUN (GET-HTTP-SERVER-SYSTEM STRING) ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "getHttpServerSystem", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("START-ONTOSAURUS", "(DEFUN START-ONTOSAURUS (|&REST| (OPTIONS OBJECT)) :DOCUMENTATION \"Start the PowerLoom HTTP server at :port (defaults to 9090).  Loads\nthe required support systems in Lisp and Java if necessary (C++ is not yet supported).\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "startOntosaurus", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "startOntosaurusEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("STOP-ONTOSAURUS", "(DEFUN STOP-ONTOSAURUS () :DOCUMENTATION \"Stop the PowerLoom HTTP server and free up any bound ports.\nThis is a no-op if no server is running or the server is not supported.\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "stopOntosaurus", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("START-POWERLOOM-SERVER", "(DEFUN START-POWERLOOM-SERVER (|&REST| (OPTIONS OBJECT)) :DOCUMENTATION \"Start the PowerLoom HTTP server at :port (defaults to 9090).  Loads\nthe required support systems in Lisp and Java if necessary (C++ is not yet supported).\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "startPowerloomServer", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "startPowerloomServerEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("STOP-POWERLOOM-SERVER", "(DEFUN STOP-POWERLOOM-SERVER () :DOCUMENTATION \"Stop the PowerLoom HTTP server and free up any bound ports.\nThis is a no-op if no server is running or the server is not supported.\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "stopPowerloomServer", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("START-POWERLOOM-GUI", "(DEFUN START-POWERLOOM-GUI (|&REST| (OPTIONS OBJECT)) :DOCUMENTATION \"Start the PowerLoom server at :port (defaults to 9090) and launches\nthe GUI which will communicate with the server at that port.  If :host is specified,\nthe GUI will try to communicate with a server at `host:port' instead of the local\nembedded server (note, you can always point the GUI manually to a different server\nfrom its `Connect to Server' menu item).  Loads the required support systems if necessary.\nEmbedded calls to the GUI are currently only supported in Java; however, when the GUI is\nrun in standalone mode, it can communicate with any PowerLoom installation that supports\nan HTTP server (currently Lisp and Java).\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "startPowerloomGui", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "startPowerloomGuiEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("STOP-POWERLOOM-GUI", "(DEFUN STOP-POWERLOOM-GUI () :DOCUMENTATION \"Closes the PowerLoom GUI application if it is currently visible.\nThis is a no-op if the GUI is not running or if it is not supported.\" :COMMAND? TRUE :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "stopPowerloomGui", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("POWERLOOM-GUI-EXIT-HOOK", "(DEFUN POWERLOOM-GUI-EXIT-HOOK ((IGNORE OBJECT)) :DOCUMENTATION \"Exit hook to stop the PowerLoom GUI if it is running.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "powerloomGuiExitHook", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("PRINT-FORMULA-CONTAINING-ERROR", "(DEFUN PRINT-FORMULA-CONTAINING-ERROR ((SELF OBJECT) (STREAM OUTPUT-STREAM)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "printFormulaContainingError", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.OutputStream")}), null);
      Stella.defineFunctionObject("HELP-SIGNAL-PROPOSITION-ERROR", "(DEFUN HELP-SIGNAL-PROPOSITION-ERROR ((STREAM OUTPUT-STREAM) (WARNINGORERROR KEYWORD)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "helpSignalPropositionError", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.OutputStream"), Native.find_java_class("edu.isi.stella.Keyword")}), null);
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION PERMUTATION-TABLE :TYPE (KEY-VALUE-LIST OF VECTOR SLOT) :OPTION-KEYWORD :PERMUTATION-TABLE :ALLOCATION :DYNAMIC)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT TABLE RELATION-PARAMETER-TYPE-SPECIFIERS :RENAMES TUPLE-DOMAINS)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT MODULE MODULE-LOGIC-DIALECT :TYPE KEYWORD :DEFAULT NULL :OPTION-KEYWORD :LOGIC-DIALECT :PUBLIC? TRUE :ALLOCATION :DYNAMIC)");
      Stella.defineFunctionObject("LOGIC-DIALECT", "(DEFUN (LOGIC-DIALECT KEYWORD) ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "logicDialect", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("LOOKUP-LOGIC-OBJECT-SURROGATE", "(DEFUN (LOOKUP-LOGIC-OBJECT-SURROGATE SURROGATE) ((NAME SYMBOL) (DEFINITIONMODULE MODULE)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "lookupLogicObjectSurrogate", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Module")}), null);
      Stella.defineFunctionObject("INTERN-LOGIC-OBJECT-SURROGATE", "(DEFUN (INTERN-LOGIC-OBJECT-SURROGATE SURROGATE) ((NAME SYMBOL)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "internLogicObjectSurrogate", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol")}), null);
      Stella.defineFunctionObject("NAME-OBJECT-METACLASS", "(DEFUN (NAME-OBJECT-METACLASS STRING) ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "nameObjectMetaclass", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("LOGIC-OBJECT-DEFINITION-TYPE", "(DEFUN (LOGIC-OBJECT-DEFINITION-TYPE KEYWORD) ((NAME SYMBOL) (OLDOBJECT OBJECT) (NEWOBJECT OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "logicObjectDefinitionType", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("BIND-LOGIC-OBJECT-TO-SURROGATE", "(DEFUN BIND-LOGIC-OBJECT-TO-SURROGATE ((NAME SYMBOL) (OBJECT OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "bindLogicObjectToSurrogate", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("REDEFINE-LOGIC-OBJECT", "(DEFUN REDEFINE-LOGIC-OBJECT ((NAME SYMBOL) (OLDOBJECT OBJECT) (NEWOBJECT OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "redefineLogicObject", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("EXPLICITLY-QUALIFIED-LOGIC-OBJECT-NAME?", "(DEFUN (EXPLICITLY-QUALIFIED-LOGIC-OBJECT-NAME? BOOLEAN) ((OBJECTNAME GENERALIZED-SYMBOL) (DEFINITIONMODULE MODULE)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "explicitlyQualifiedLogicObjectNameP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.GeneralizedSymbol"), Native.find_java_class("edu.isi.stella.Module")}), null);
      Stella.defineFunctionObject("COERCE-TO-BOUND-OR-LOCAL-SURROGATE", "(DEFUN (COERCE-TO-BOUND-OR-LOCAL-SURROGATE SURROGATE) ((SELF GENERALIZED-SYMBOL)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "coerceToBoundOrLocalSurrogate", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.GeneralizedSymbol")}), null);
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT LOGIC-OBJECT OBJECT-AXIOMS :TYPE CONS :DEFAULT NULL :READER AXIOMS :OPTION-KEYWORD :AXIOMS :OPTION-HANDLER DEFINITION-AXIOMS-HANDLER :ALLOCATION :DYNAMIC)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT PROPOSITION PROPOSITION-AXIOMS :TYPE CONS :DEFAULT NULL :WRITER AXIOMS-SETTER :OPTION-KEYWORD :AXIOMS :OPTION-HANDLER DEFINITION-AXIOMS-HANDLER :ALLOCATION :DYNAMIC)");
    }
  }

  static void helpStartupLogicIn4() {
    {
      Stella.defineFunctionObject("AXIOMS", "(DEFUN (AXIOMS CONS) ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "axioms", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("AXIOMS-SETTER", "(DEFUN (AXIOMS-SETTER OBJECT) ((SELF OBJECT) (AXIOMS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "axiomsSetter", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS1 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<= :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS2 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :=> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS3 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<= :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS4 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :=>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS5 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<=> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS6 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<=>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS7 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<=> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS8 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<=>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS9 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<~ :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS10 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :~> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS11 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<~ :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS12 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :~>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS13 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<~> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS14 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<~>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS15 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<~> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineExternalSlotFromStringifiedSource("(DEFSLOT NAMED-DESCRIPTION AXIOMS-ALIAS16 :RENAMES OBJECT-AXIOMS :OPTION-KEYWORD :<<~>> :OPTION-HANDLER DEFINITION-HALF-RULE-HANDLER)");
      Stella.defineFunctionObject("DEFINITION-AXIOMS-HANDLER", "(DEFUN DEFINITION-AXIOMS-HANDLER ((SELF OBJECT) (SLOT STORAGE-SLOT) (THEAXIOMS OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "definitionAxiomsHandler", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.StorageSlot"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("DEFINITION-HALF-RULE-HANDLER", "(DEFUN DEFINITION-HALF-RULE-HANDLER ((SELF NAMED-DESCRIPTION) (SLOT STORAGE-SLOT) (BODY OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.NamedDescription", "definitionHalfRuleHandler", new java.lang.Class [] {Native.find_java_class("edu.isi.powerloom.logic.NamedDescription"), Native.find_java_class("edu.isi.stella.StorageSlot"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("COMBINE-AXIOM-LISTS", "(DEFUN (COMBINE-AXIOM-LISTS CONS) ((OLDAXIOMS CONS) (NEWAXIOMS OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "combineAxiomLists", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("YIELD-RELATION-PARAMETERS-TREE", "(DEFUN (YIELD-RELATION-PARAMETERS-TREE CONS) ((SELF NAMED-DESCRIPTION) (DROPFUNCTIONPARAMETER? BOOLEAN) (TYPED? BOOLEAN)))", Native.find_java_method("edu.isi.powerloom.logic.NamedDescription", "yieldRelationParametersTree", new java.lang.Class [] {Native.find_java_class("edu.isi.powerloom.logic.NamedDescription"), java.lang.Boolean.TYPE, java.lang.Boolean.TYPE}), null);
      Stella.defineFunctionObject("COMPLETE-RULE-DEFINITION", "(DEFUN (COMPLETE-RULE-DEFINITION OBJECT) ((SELF NAMED-DESCRIPTION) (BODY OBJECT) (ARROW SYMBOL)))", Native.find_java_method("edu.isi.powerloom.logic.NamedDescription", "completeRuleDefinition", new java.lang.Class [] {Native.find_java_class("edu.isi.powerloom.logic.NamedDescription"), Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Symbol")}), null);
      Stella.defineFunctionObject("DEFINITION-KEYWORD-AXIOMS-HANDLER", "(DEFUN DEFINITION-KEYWORD-AXIOMS-HANDLER ((SELF OBJECT) (SELFNAME SYMBOL) (KEY KEYWORD) (VALUE OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "definitionKeywordAxiomsHandler", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Keyword"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("HELP-DEFINE-KEYWORD-AXIOMS", "(DEFUN (HELP-DEFINE-KEYWORD-AXIOMS CONS) ((SELFNAME SYMBOL) (KEY KEYWORD) (VALUE OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "helpDefineKeywordAxioms", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Keyword"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("ASSERT-KEYWORD-AXIOM", "(DEFUN ASSERT-KEYWORD-AXIOM ((SELF OBJECT) (SELFNAME SYMBOL) (KEY KEYWORD) (VALUE OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "assertKeywordAxiom", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("edu.isi.stella.Keyword"), Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("REGISTER-UNFINALIZED-OBJECT", "(DEFUN REGISTER-UNFINALIZED-OBJECT ((OBJECT OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "registerUnfinalizedObject", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("CLEANUP-UNFINALIZED-OBJECTS", "(DEFUN CLEANUP-UNFINALIZED-OBJECTS ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "cleanupUnfinalizedObjects", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("LINK-ORIGINATED-PROPOSITION", "(DEFUN LINK-ORIGINATED-PROPOSITION ((OBJECT OBJECT) (PROPOSITION PROPOSITION)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "linkOriginatedProposition", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object"), Native.find_java_class("edu.isi.powerloom.logic.Proposition")}), null);
      Stella.defineFunctionObject("HELP-FINALIZE-OBJECT-AXIOMS", "(DEFUN (HELP-FINALIZE-OBJECT-AXIOMS (CONS OF PROPOSITION)) ((THEAXIOMS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "helpFinalizeObjectAxioms", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("FINALIZE-OBJECT-AXIOMS", "(DEFUN FINALIZE-OBJECT-AXIOMS ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "finalizeObjectAxioms", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("CHECK-DESCRIPTION-ARGUMENT-TYPES", "(DEFUN CHECK-DESCRIPTION-ARGUMENT-TYPES ((SELF NAMED-DESCRIPTION)))", Native.find_java_method("edu.isi.powerloom.logic.NamedDescription", "checkDescriptionArgumentTypes", new java.lang.Class [] {Native.find_java_class("edu.isi.powerloom.logic.NamedDescription")}), null);
      Stella.defineFunctionObject("FINALIZE-OBJECT", "(DEFUN FINALIZE-OBJECT ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "finalizeObject", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("FINALIZED-OBJECT?", "(DEFUN (FINALIZED-OBJECT? BOOLEAN) ((SELF OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "finalizedObjectP", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), null);
      Stella.defineFunctionObject("OBJECTS-ARE-FINALIZED?", "(DEFUN (OBJECTS-ARE-FINALIZED? BOOLEAN) () :GLOBALLY-INLINE? TRUE (RETURN (EMPTY? (THE-CONS-LIST *UNFINALIZED-OBJECTS*))))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "objectsAreFinalizedP", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("FINALIZE-OBJECTS", "(DEFUN FINALIZE-OBJECTS () :DOCUMENTATION \"Finalize all currently unfinalized objects.\nThe user-level entry point for this is `(process-definitions)'.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "finalizeObjects", new java.lang.Class [] {}), null);
      Stella.defineFunctionObject("HELP-DEFINE-RELATION-FROM-PARSE-TREE", "(DEFUN (HELP-DEFINE-RELATION-FROM-PARSE-TREE NAMED-DESCRIPTION) ((TREE CONS) (STRINGIFIEDSOURCE STRING)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "helpDefineRelationFromParseTree", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons"), Native.find_java_class("java.lang.String")}), null);
      Stella.defineFunctionObject("PARSE-RELATION-PARAMETERS-TREE", "(DEFUN (PARSE-RELATION-PARAMETERS-TREE (LIST OF SYMBOL) (LIST OF TYPE) BOOLEAN) ((PARAMETERS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "parseRelationParametersTree", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons"), Native.find_java_class("[Ljava.lang.Object;")}), null);
      Stella.defineFunctionObject("GET-IDENTICAL-RELATION", "(DEFUN (GET-IDENTICAL-RELATION NAMED-DESCRIPTION) ((NAME SYMBOL) (STRINGIFIEDSOURCE STRING)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "getIdenticalRelation", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Symbol"), Native.find_java_class("java.lang.String")}), null);
      Stella.defineMethodObject("(DEFMETHOD PROCESS-DEFINITION-OPTIONS ((SELF NAMED-DESCRIPTION) (OPTIONS OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.NamedDescription", "processDefinitionOptions", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), ((java.lang.reflect.Method)(null)));
      Stella.defineFunctionObject("DEFFUNCTION", "(DEFUN (DEFFUNCTION NAMED-DESCRIPTION) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a logic function.  The accepted syntax is:\n	 \n (deffunction <funconst> (<vardecl>+) [:-> <vardecl>]\n    [:documentation <string>]\n    [:<= <sentence>] | [:=> <sentence>] |\n    [:<<= <sentence>] | [:=>> <sentence>] | \n    [:<=> <sentence>] | [:<=>> <sentence>] |\n    [:<<=> <sentence>] | [:<<=>> <sentence>] |\n    [:axioms {<sentence> | (<sentence>+)}]\n    [<keyword-option>*])\n	\nFunction parameters can be typed or untyped.  If the `:->' option is\nsupplied, it specifies the output variable of the function.  Otherwise,\nthe last variable in the parameter list is used as the output variable.\nSee `defrelation' for a description of `<keyword-option>'s.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "deffunction", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "deffunctionEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("CALL-DEFFUNCTION", "(DEFUN (CALL-DEFFUNCTION NAMED-DESCRIPTION) ((ARGUMENTS CONS)) :DOCUMENTATION \"Callable version of the `deffunction' command (which see).\nExpects the same arguments as `deffunction' but supplied as a list.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "callDeffunction", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("NORMALIZE-DEFFUNCTION-ARGUMENTS", "(DEFUN (NORMALIZE-DEFFUNCTION-ARGUMENTS CONS) ((ARGUMENTS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "normalizeDeffunctionArguments", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEFRELATION", "(DEFUN (DEFRELATION NAMED-DESCRIPTION) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a logic relation.  The accepted syntax is:\n	 \n (defrelation <relconst> (<vardecl>+)\n    [:documentation <string>]\n    [:<= <sentence>] | [:=> <sentence>] |\n    [:<<= <sentence>] | [:=>> <sentence>] | \n    [:<=> <sentence>] | [:<=>> <sentence>] |\n    [:<<=> <sentence>] | [:<<=>> <sentence>] |\n    [:axioms {<sentence> | (<sentence>+)}]\n    [<keyword-option>*])\n	\nRelation parameters can be typed or untyped.\n`<keyword-option>' represents a keyword followed by a value that states an\nassertion about `<relconst>'.  For example, including the option `:foo bar'\nstates that the proposition `(foo <relconst> bar)' is true.  `:foo (bar fum)'\nstates that both `(foo <relconst> bar)' and `(foo <relconst> fum)' are true.\n`:foo true' states that `(foo <relconst>)' is true, `:foo false' states that\n`(not (foo <relconst>))' is true.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defrelation", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "defrelationEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("CALL-DEFRELATION", "(DEFUN (CALL-DEFRELATION NAMED-DESCRIPTION) ((ARGUMENTS CONS)) :DOCUMENTATION \"Callable version of the `defrelation' command (which see).\nExpects the same arguments as `defrelation' but supplied as a list.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "callDefrelation", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("NORMALIZE-DEFRELATION-ARGUMENTS", "(DEFUN (NORMALIZE-DEFRELATION-ARGUMENTS CONS) ((ARGUMENTS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "normalizeDefrelationArguments", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEFCONCEPT", "(DEFUN (DEFCONCEPT NAMED-DESCRIPTION) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a concept.  The accepted syntax is:\n	 \n (defconcept <conceptconst> [(<var> <parent>*)]\n    [:documentation <string>]\n    [:<= <sentence>] | [:=> <sentence>] |\n    [:<<= <sentence>] | [:=>> <sentence>] | \n    [:<=> <sentence>] | [:<=>> <sentence>] | [:<<=> <sentence>] |\n    [:<<=>> <sentence>] |\n    [:axioms {<sentence> | (<sentence>+)}] |\n    <keyword-option>*)\n	\nDeclaration of a concept variable `<var>' is optional, unless any\nimplication (arrow) options are supplied that need to reference it.  A\npossibly empty list of concept names following `<var>' is taken as the list\nof parents of `<conceptconst>'.  Alternatively, parents can be specified\nvia the `:=>' option.  If no parents are specified, the parent of\n`<conceptconst>' is taken to be THING.  `<keyword-option>' represents a\nkeyword followed by a value that states an assertion about `<conceptconst>'.\nSee `defrelation' for a description of `<keyword-option>'s.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defconcept", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "defconceptEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("CALL-DEFCONCEPT", "(DEFUN (CALL-DEFCONCEPT NAMED-DESCRIPTION) ((ARGUMENTS CONS)) :DOCUMENTATION \"Callable version of the `defconcept' command (which see).\nExpects the same arguments as `defconcept' but supplied as a list.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "callDefconcept", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("NORMALIZE-DEFCONCEPT-ARGUMENTS", "(DEFUN (NORMALIZE-DEFCONCEPT-ARGUMENTS CONS) ((ARGUMENTS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "normalizeDefconceptArguments", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEFINE-RELATION-FROM-PARSE-TREE", "(DEFUN (DEFINE-RELATION-FROM-PARSE-TREE NAMED-DESCRIPTION) ((TREE CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defineRelationFromParseTree", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("DEFOBJECT", "(DEFUN (DEFOBJECT LOGIC-OBJECT) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a logic instance.  The accepted syntax is:\n	 \n (defobject <constant>\n    [:documentation <string>]\n    [<keyword-option>*])\n	\n`<keyword-option>' represents a keyword followed by a value\nthat states an assertion about <constant>.  See `defrelation' for a\ndescription of `<keyword-option>'s.\n\n`defobject' provides a sugar-coated way to assert a collection of facts\nabout a logic constant, but otherwise adds nothing in terms of functionality.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defobject", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "defobjectEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("DEFINSTANCE", "(DEFUN (DEFINSTANCE LOGIC-OBJECT) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a logic instance (`definstance' is an alias\nfor `defobject' which see).\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "definstance", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "definstanceEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("CALL-DEFOBJECT", "(DEFUN (CALL-DEFOBJECT LOGIC-OBJECT) ((ARGUMENTS CONS)) :DOCUMENTATION \"Callable version of the `defobject' command (which see).\nExpects the same arguments as `defobject' but supplied as a list.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "callDefobject", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("NORMALIZE-DEFOBJECT-ARGUMENTS", "(DEFUN (NORMALIZE-DEFOBJECT-ARGUMENTS CONS) ((ARGUMENTS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "normalizeDefobjectArguments", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineMethodObject("(DEFMETHOD PROCESS-DEFINITION-OPTIONS ((SELF LOGIC-OBJECT) (OPTIONS OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.LogicObject", "processDefinitionOptions", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), ((java.lang.reflect.Method)(null)));
      Stella.defineFunctionObject("DEFPROPOSITION", "(DEFUN (DEFPROPOSITION PROPOSITION) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a named proposition.  The accepted syntax is:\n	 \n (defproposition <name> <sentence>\n    [:documentation <string>]\n    [:forward-only? {true | false}]\n    [:backward-only? {true | false}]\n    [:dont-optimize? {true | false}]\n    [:confidence-level {:strict | :default}]\n    [<keyword-option>*])\n	\n<sentence> can be any sentence that is legal as a top-level assertion.\n<name> can be a string or symbol and will be bound to the asserted\nproposition represented by <sentence>.  After this definition every\noccurrence of <name> will be replaced by the associated proposition.\n\nThe options :forward-only? and :backward-only? can be used to tell the\ninference engine to only use the rule in forward or backward direction\n(this can also be achieved by using the `<<=' or `=>>' implication\narrows).  :dont-optimize?  tells the inference engine to not rearrange\nthe order of clauses in the antecedent of a rule and instead evaluate\nthem in their original order.  :confidence-level can be used to mark a\nproposition as default only.\n\n`<keyword-option>' represents a keyword followed by a value\nthat states an assertion about the proposition <name>.  See `defrelation'\nfor a description of `<keyword-option>'s.\n\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defproposition", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "defpropositionEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("DEFRULE", "(DEFUN (DEFRULE PROPOSITION) (|&REST| (ARGS PARSE-TREE)) :PUBLIC? TRUE :COMMAND? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Define (or redefine) a named rule (`defrule' is an alias\nfor `defproposition' which see).\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "defrule", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "defruleEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
      Stella.defineFunctionObject("CALL-DEFPROPOSITION", "(DEFUN (CALL-DEFPROPOSITION PROPOSITION) ((ARGUMENTS CONS)) :DOCUMENTATION \"Callable version of the `defproposition' command (which see).\nExpects the same arguments as `defproposition' but supplied as a list.\" :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic.Logic", "callDefproposition", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineFunctionObject("NORMALIZE-DEFPROPOSITION-ARGUMENTS", "(DEFUN (NORMALIZE-DEFPROPOSITION-ARGUMENTS CONS) ((ARGUMENTS CONS)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "normalizeDefpropositionArguments", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), null);
      Stella.defineMethodObject("(DEFMETHOD PROCESS-DEFINITION-OPTIONS ((SELF PROPOSITION) (OPTIONS OBJECT)))", Native.find_java_method("edu.isi.powerloom.logic.Proposition", "processDefinitionOptions", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Stella_Object")}), ((java.lang.reflect.Method)(null)));
    }
  }

  public static void startupLogicIn() {
    { Object old$Module$000 = Stella.$MODULE$.get();
      Object old$Context$000 = Stella.$CONTEXT$.get();

      try {
        Native.setSpecial(Stella.$MODULE$, Stella.getStellaModule("/LOGIC", Stella.$STARTUP_TIME_PHASE$ > 1));
        Native.setSpecial(Stella.$CONTEXT$, ((Module)(Stella.$MODULE$.get())));
        if (Stella.currentStartupTimePhaseP(2)) {
          _StartupLogicIn.helpStartupLogicIn1();
        }
        if (Stella.currentStartupTimePhaseP(4)) {
          _StartupLogicIn.helpStartupLogicIn2();
        }
        if (Stella.currentStartupTimePhaseP(6)) {
          Stella.finalizeClasses();
        }
        if (Stella.currentStartupTimePhaseP(7)) {
          _StartupLogicIn.helpStartupLogicIn3();
          _StartupLogicIn.helpStartupLogicIn4();
          Stella.defineFunctionObject("COMMAND<", "(DEFUN (COMMAND< BOOLEAN) ((COMMAND1 METHOD-SLOT) (COMMAND2 METHOD-SLOT)))", Native.find_java_method("edu.isi.powerloom.logic.Logic", "commandL", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.MethodSlot"), Native.find_java_class("edu.isi.stella.MethodSlot")}), null);
          Stella.defineFunctionObject("LIST-LOGIC-COMMANDS", "(DEFUN (LIST-LOGIC-COMMANDS (LIST OF METHOD-SLOT)) ())", Native.find_java_method("edu.isi.powerloom.logic.Logic", "listLogicCommands", new java.lang.Class [] {}), null);
          Stella.defineFunctionObject("HELP", "(DEFUN HELP (|&REST| (COMMANDS SYMBOL)) :COMMAND? TRUE :PUBLIC? TRUE :EVALUATE-ARGUMENTS? FALSE :DOCUMENTATION \"Describe specific commands, or print a list of available commands.\")", Native.find_java_method("edu.isi.powerloom.logic.Logic", "help", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}), Native.find_java_method("edu.isi.powerloom.logic.Logic", "helpEvaluatorWrapper", new java.lang.Class [] {Native.find_java_class("edu.isi.stella.Cons")}));
          Stella.defineFunctionObject("STARTUP-LOGIC-IN", "(DEFUN STARTUP-LOGIC-IN () :PUBLIC? TRUE)", Native.find_java_method("edu.isi.powerloom.logic._StartupLogicIn", "startupLogicIn", new java.lang.Class [] {}), null);
          { MethodSlot function = Symbol.lookupFunction(Logic.SYM_LOGIC_STARTUP_LOGIC_IN);

            KeyValueList.setDynamicSlotValue(function.dynamicSlots, Logic.SYM_STELLA_METHOD_STARTUP_CLASSNAME, StringWrapper.wrapString("_StartupLogicIn"), Stella.NULL_STRING_WRAPPER);
          }
        }
        if (Stella.currentStartupTimePhaseP(8)) {
          Stella.finalizeSlots();
          Stella.cleanupUnfinalizedClasses();
        }
        if (Stella.currentStartupTimePhaseP(9)) {
          Stella_Object.inModule(((StringWrapper)(Stella_Object.copyConsTree(StringWrapper.wrapString("LOGIC")))));
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *AVAILABLE-POWERLOOM-FEATURES* (LIST OF KEYWORD) (LIST :TRACE-SUBGOALS :TRACE-SOLUTIONS :TRACE-CLASSIFIER :ITERATIVE-DEEPENING :JUSTIFICATIONS :JUST-IN-TIME-INFERENCE :EMIT-THINKING-DOTS) :DOCUMENTATION \"List of PowerLoom environment features.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *CURRENT-POWERLOOM-FEATURES* (LIST OF KEYWORD) (LIST) :DOCUMENTATION \"List of currently enabled PowerLoom environment features.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *DEFAULT-POWERLOOM-FEATURES* (LIST OF KEYWORD) (LIST :JUST-IN-TIME-INFERENCE :EMIT-THINKING-DOTS) :DOCUMENTATION \"List of PowerLoom environment features enabled upon call to\n'reset-features'.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *LOGIC-PROMPT* STRING \"|= \" :DOCUMENTATION \"The prompt used by the PowerLoom listener.\" :PUBLIC? TRUE)");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *PROMPT-SHOW-MODULE?* BOOLEAN TRUE :DOCUMENTATION \"Flag to control whether the logic prompt shows the module name.\" :PUBLIC? TRUE)");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *LOGIC-COMMAND-RESULT-INDENT* STRING \"\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *CAREFUL-LOGIC-COMMAND-LOOP-EXIT*? BOOLEAN (VERBATIM :COMMON-LISP FALSE :OTHERWISE TRUE) :DOCUMENTATION \"If TRUE exiting from the logic-command loop (or PowerLoom\nlistener) will be protected by a confirmation dialog.  This is mainly useful\nfor C++ where exiting the listener will also exit the program.\" :PUBLIC? TRUE)");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *POWERLOOM-KB-FILE-EXTENSIONS* CONS (QUOTE (\".plm\" \".ploom\")) :DOCUMENTATION \"If the extension of a KB file is unspecified in a\n`load' or `demo' command, try to find it with one of these extensions.\" :PUBLIC? TRUE)");
          Stella.addLoadPath("PL:kbs;");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *DEMO-LEVEL* INTEGER 0)");
          Stella.addLoadPath("PL:sources;logic;demos;");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *DEMO-FILES* (CONS OF (CONS OF STRING-WRAPPER)) (BQUOTE ((\"basics\" \"Basic PowerLoom commands\" \"test-suite\") (\"classes\" \"Primitive and defined classes\" \"test-suite\") (\"collections\" \"Reasoning with collections\" \"test-suite\") (\"append\" \"Prolog-style `append'\" \"test-suite\") (\"inequalities\" \"Reasoning with inequalities\" \"test-suite\") (\"recursion\" \"Reasoning with recursive rules\" \"test-suite\") (\"negation\" \"Reasoning with negation\" \"test-suite\") (\"constraints\" \"Constraint propagation\" \"test-suite\") (\"equations\" \"Simple equational reasoning\" \"test-suite\") (\"subsumption\" \"Simple subsumption reasoning\" \"test-suite\") (\"family\" \"Subsumption reasoning within a family ontology\" \"test-suite\") (\"relation-hierarchy\" \"Finding sub, super and equivalent concepts and relations\" \"test-suite\") (\"defaults\" \"Default reasoning with Tweety and friends\" \"test-suite\") (\"defaults2\" \"More default reasoning\" \"test-suite\") (\"definition-syntax\" \"The whole scoop on relation definition, funny arrows, etc.\" \"test-suite\") (\"meta-relations\" \"Using meta-properties and relations\" \"test-suite\") (\"partial-match\" \"Reasoning with partial information\" \"test-suite\") (\"probability-learning\" \"Learning to answer probabilistic queries\" \"test-suite\") (\"regression-demo\" \"Learning to predict functions\") (\"rule-induction-demo\" \"Learning inference rules\") (\"test-suite\" \"PowerLoom test suite\" \"test-suite\"))) :DOCUMENTATION \"List of example demo files.\nEach entry is a `(<file> <description>)' pair.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *TERMSOURCEBEINGPARSED* STRING NULL :DOCUMENTATION \"Points to the source of the relation being parsed.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *DESCRIPTIONUNDERCONSTRUCTION* OBJECT NULL :DOCUMENTATION \"Pofints to a description or its parse tree which\nis the input to the description being constructed.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *TERMUNDERCONSTRUCTION* OBJECT NULL :DOCUMENTATION \"Points to the parse tree which is the input to the\nproposition being constructed.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *EXPRESSION-SIZE-CUTOFF* INTEGER 300 :DOCUMENTATION \"Limit on how big an s-expression we will print within\nan error message.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *HANDLE-EXPLICITLY-QUALIFIED-LOGIC-OBJECTS?* BOOLEAN TRUE)");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *UNFINALIZED-OBJECTS* LIST (LIST) :DOCUMENTATION \"List of objects whose definitions and/or associated\naxioms and constraints are not yet processed.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *FINALIZEOBJECTSIMMEDIATELY?* BOOLEAN FALSE)");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFSPECIAL *INHIBITOBJECTFINALIZATION?* BOOLEAN FALSE :DOCUMENTATION \"Used to prevent finalization from triggering in the\nmiddle of 'delicate' computations.  Also used to prevent recursive\ninvocation of 'finalize-objects'.\")");
          Stella.defineStellaGlobalVariableFromStringifiedSource("(DEFGLOBAL *LOGIC-RELEVANT-STELLA-COMMANDS* (CONS OF SYMBOL) (BQUOTE (CC CLEAR-MODULE DEFMODULE IN-MODULE LIST-MODULES)))");
        }

      } finally {
        Stella.$CONTEXT$.set(old$Context$000);
        Stella.$MODULE$.set(old$Module$000);
      }
    }
  }

}
