|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |