Uses of Class
ai.krr.fol.Sentence

Packages that use Sentence
ai.krr.fol   
 

Uses of Sentence in ai.krr.fol
 

Subclasses of Sentence in ai.krr.fol
 class Atom
           An Atom is one of the most basic building blocks for a Sentence.
 class BinaryConnectedSentence
           This class represents a Sentence that consists of a Connective that connects two sub-Sentences.
 class ConnectedSentence
           This class represents a Sentence that consists of a Connective that connects a number of (at least two) sub-Sentences.
 class Literal
           A Literal is one of the most basic building blocks for a Sentence.
 class NegatedSentence
           A NegatedSentence is the simplest kind of complex Sentence.
 class QuantifiedSentence
           
 class TruthValue
           A TruthValue is one of the most basic building blocks for a Sentence.
 

Fields in ai.krr.fol declared as Sentence
protected  Sentence QuantifiedSentence.contained
          the content Sentence
protected  Sentence NegatedSentence.contained
          the contained Sentence that is negated
protected  Sentence[] ConnectedSentence.sentences
          the sub-Sentences connected here
 

Fields in ai.krr.fol with type parameters of type Sentence
protected  java.util.List<Sentence> KnowledgeBase.beliefs
          the List of Sentences that hold in this KB
 

Methods in ai.krr.fol that return Sentence
abstract  Sentence Sentence.clone()
           Returns a copy of this Sentence.
abstract  Sentence Sentence.clone(Substitution s)
           Returns a copy of this Sentence with free Variables replaced according to the given Substitution.
 Sentence NegatedSentence.getContainedSentence()
           This function returns the Sentence that is contained in this NegatedSentence.
 Sentence QuantifiedSentence.getContent()
          This function returns the contained Sentence.
 Sentence BinaryConnectedSentence.getLeftHandSide()
           This function returns the left-hand side sub-Sentence of this BinaryConnectedSentence.
 Sentence BinaryConnectedSentence.getRightHandSide()
           This function returns the right-hand side sub-Sentence of this BinaryConnectedSentence.
 Sentence[] ConnectedSentence.getSubSentences()
           This function returns the the sub-Sentences that are joined in this ConnectedSentence.
 Sentence Sentence.SubSentenceIterator.next()
           
 Sentence XfolSentenceAdaptor.parseNodeTree(org.w3c.dom.Element root)
           This function takes a DOM Document and generates an internal representation of the statement in the representation R that represents the content of the given Document.
protected  Sentence XfolSentenceAdaptor.parseSentence(org.w3c.dom.Element node, java.util.Map<java.lang.String,NameSpace> proxies)
           
static Sentence KifSentenceAdaptor.parseSentence(inf.compilers.LexicalAnalyzer scanner, java.util.Properties props, KifSentenceAdaptor.VariableStack allVars)
           This function attempts to parse a propositional Sentence in KIF syntax from the underlying LexicalAnalyzer.
 Sentence KifSentenceAdaptor.read(java.io.Reader r)
           This function attempts to parse characters from the given Reader until a Sentence that represents an object in the internal representation has been parsed.
static Sentence Sentence.read(java.io.Reader r, inf.compilers.SyntaxAdaptor<Sentence> sa)
           
 Sentence Sentence.skolemize()
           This function computes a skolemized version of this Sentence.
protected  Sentence TruthValue.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected abstract  Sentence Sentence.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence QuantifiedSentence.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence NegatedSentence.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence Literal.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence ConnectedSentence.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence BinaryConnectedSentence.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
protected  Sentence Atom.skolemize(boolean isNegated, Term[] uqVars, Substitution s)
           This function computes a skolemized version of this Sentence.
 Sentence Sentence.toCNF()
          This function returns a new Sentence which is the CNF of this Sentence.
protected  Sentence TruthValue.toCNF(boolean isNegated)
           This function returns a new TruthValue which contains the same BooleanSymbol or its negation, depending on the given boolean.
protected abstract  Sentence Sentence.toCNF(boolean isNegated)
          This function returns a new Sentence which is the CNF of this Sentence.
protected  Sentence QuantifiedSentence.toCNF(boolean isNegated)
           This function returns a new Sentence which is the CNF of this Sentence.
protected  Sentence NegatedSentence.toCNF(boolean isNegated)
           This function returns a new Literal which contains the proposition contained in this Atom.
protected  Sentence Literal.toCNF(boolean isNegated)
          This function returns a new Literal which contains the proposition contained in this Atom.
protected  Sentence ConnectedSentence.toCNF(boolean isNegated)
           This function returns a new Sentence which is the CNF form of this ConnectedSentence.
protected  Sentence BinaryConnectedSentence.toCNF(boolean isNegated)
           This function returns a new Sentence which is the CNF of this Sentence.
protected  Sentence Atom.toCNF(boolean isNegated)
          This function returns a new Literal which contains the proposition contained in this Atom.
 Sentence Sentence.toDNF()
          This function returns a new Sentence which is the DNF of this Sentence.
protected  Sentence TruthValue.toDNF(boolean isNegated)
           This function returns a new TruthValue which contains the same BooleanSymbol or its negation, depending on the given boolean.
protected abstract  Sentence Sentence.toDNF(boolean isNegated)
          This function returns a new Sentence which is the DNF of this Sentence.
protected  Sentence QuantifiedSentence.toDNF(boolean isNegated)
           This function returns a new Sentence which is the CNF of this Sentence.
protected  Sentence NegatedSentence.toDNF(boolean isNegated)
           This function returns a new Literal which contains the proposition contained in this Atom.
protected  Sentence Literal.toDNF(boolean isNegated)
          This function returns a new Literal which contains the proposition contained in this Atom.
protected  Sentence ConnectedSentence.toDNF(boolean isNegated)
          This function returns a new Sentence which is the CNF form of this AndOrSentence.
protected  Sentence BinaryConnectedSentence.toDNF(boolean isNegated)
           This function returns a new Sentence which is the DNF of this Sentence.
protected  Sentence Atom.toDNF(boolean isNegated)
          This function returns a new Literal which contains the proposition contained in this Atom.
 Sentence Clause.toSentence()
           This function converts this Clause to an ordinary first-order Sentence, which is either TruthValue.FALSE for the empty Clause, a Literal for a unit Clause, or a disjunction of the Literals in this Clause.
 

Methods in ai.krr.fol that return types with arguments of type Sentence
 java.util.Iterator<Sentence> Sentence.allSubSentences()
           This function can be used to iterate through all the sub-Sentences of this Sentence, including the Sentence itself.
 java.lang.Class<Sentence> XfolSentenceAdaptor.getInternalClass()
           This function returns the Class that holds the internal representation this adaptor translates to and from.
 java.lang.Class<Sentence> KifSentenceAdaptor.getInternalClass()
           This function returns the Class that holds the internal representation this adaptor translates to and from.
protected static java.util.List<Sentence> KifSentenceAdaptor.parseConnectedSentences(inf.compilers.LexicalAnalyzer scanner, java.util.Properties props, KifSentenceAdaptor.VariableStack allVars)
           This function attempts to parse a sequence of at least two Sentences from the underlying LexicalAnalyzer.
 

Methods in ai.krr.fol with parameters of type Sentence
 void KnowledgeBase.add(Sentence stmt)
           This function asserts the given Sentence in this KnowledgeBase.
 int TruthValue.compareTo(Sentence stmt)
          This function compares this Sentence to the given Sentence.
abstract  int Sentence.compareTo(Sentence stmt)
          This function compares this Sentence to the given Sentence.
 int QuantifiedSentence.compareTo(Sentence stmt)
          This function compares this Sentence to the given Sentence.
 int NegatedSentence.compareTo(Sentence other)
          This function compares this Sentence to the given Sentence.
 int Literal.compareTo(Sentence other)
           This function compares this Literal to the given Sentence.
 int ConnectedSentence.compareTo(Sentence stmt)
           This function compares this Sentence to the given Sentence.
 int Atom.compareTo(Sentence other)
           This function compares this Atom to the given Sentence.
 boolean KnowledgeBase.entails(Sentence stmt)
           This function tests whether the given Sentence holds in this KnowledgeBase.
 boolean TheoremProver.equivalent(Sentence stmt1, Sentence stmt2)
           This function tests whether the two given Sentences are equivalent.
 boolean HerbrandGenerator.equivalent(Sentence stmt1, Sentence stmt2)
           
 boolean KnowledgeBase.falsifies(Sentence stmt)
           This function tests whether the given Sentence does not hold in this KnowledgeBase.
 boolean TheoremProver.follows(Sentence stmt, java.util.Collection<Sentence> axioms)
           This function tests whether the given Sentence logically follows from the given Collection of Sentences.
 boolean HerbrandGenerator.follows(Sentence stmt, java.util.Collection<Sentence> axioms)
           
 org.w3c.dom.Element XfolSentenceAdaptor.generateNodeTree(org.w3c.dom.Document doc, Sentence content)
           This function generates an Element Node that is the root for the given content.
 org.w3c.dom.Element XfolSentenceAdaptor.generateSentenceNode(org.w3c.dom.Document doc, Sentence content, java.util.Set<NameSpace> nss)
           This function generates an Element Node that is the root for the given content.
 boolean TheoremProver.isInconsistent(Sentence stmt)
           This function tests whether the given Sentence in first-order logic is inconsistent.
 boolean HerbrandGenerator.isInconsistent(Sentence stmt)
           
 boolean TheoremProver.isValid(Sentence stmt)
           This function tests whether the given Sentence in first-order logic is valid.
 boolean HerbrandGenerator.isValid(Sentence stmt)
           
 void KifSentenceAdaptor.prettyPrint(int indent, Sentence stmt, java.io.Writer w)
           This function takes a logical Sentence which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the KIF syntax.
static void KifSentenceAdaptor.prettyPrintSentence(int indent, Sentence stmt, java.io.Writer w, java.util.Properties props)
           This function takes a logical Sentence which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the KIF syntax.
 void KnowledgeBase.retract(Sentence stmt)
           This function deletes the given Sentence from this KnowledgeBase.
 void KifSentenceAdaptor.write(Sentence stmt, java.io.Writer w)
           This function takes a logical Sentence which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the KIF syntax.
static void KifSentenceAdaptor.writeSentence(Sentence stmt, java.io.Writer w, java.util.Properties props)
           This function takes a logical Sentence which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the KIF syntax.
 

Method parameters in ai.krr.fol with type arguments of type Sentence
 boolean TheoremProver.follows(Sentence stmt, java.util.Collection<Sentence> axioms)
           This function tests whether the given Sentence logically follows from the given Collection of Sentences.
 boolean HerbrandGenerator.follows(Sentence stmt, java.util.Collection<Sentence> axioms)
           
static Sentence Sentence.read(java.io.Reader r, inf.compilers.SyntaxAdaptor<Sentence> sa)
           
 

Constructors in ai.krr.fol with parameters of type Sentence
BinaryConnectedSentence(Sentence lhs, ConnectedSentence.Connective connective, Sentence rhs)
           This constructor for a BinaryConnectedSentence takes a Connective and two Sentences which are the Sentences that are connected by the given connective.
ConnectedSentence(ConnectedSentence.Connective connective, Sentence... sentences)
           This constructor for a ConnectedSentence takes a Connective and a number of Sentences which are the Sentences that are connected by the given connective.
ConnectedSentence(Sentence s1, ConnectedSentence.Connective connective, Sentence s2)
           This constructor for a ConnectedSentence takes a Connective and two Sentences which are the Sentences that are connected by the given connective.
NegatedSentence(Sentence stmt)
           This constructor for a NegatedSentence simply takes the Sentence that is negated.
QuantifiedSentence(QuantifiedSentence.Quantifier q, Variable[] vars, Sentence content)
           This constructor for a QuantifiedSentence takes a Quantifier, a List of Variables, and a Sentence.
QuantifiedSentence(QuantifiedSentence.Quantifier q, Variable var, Sentence content)
           This constructor for a QuantifiedSentence takes a Quantifier, a single Variable, and a Sentence.
 

Constructor parameters in ai.krr.fol with type arguments of type Sentence
ConnectedSentence(ConnectedSentence.Connective connective, java.util.List<Sentence> sents)
           This constructor for a ConnectedSentence takes a Connective and a List of Sentences which are the Sentences that are connected by the given connective.