PMII - JAVA-Packages - Principia Mathematica II

Uses of Interface
com.meyling.principia.argument.Argument

Packages that use Argument
com.meyling.principia.argument   
com.meyling.principia.html   
com.meyling.principia.io   
com.meyling.principia.latex   
com.meyling.principia.logic.basic   
com.meyling.principia.logic.paragraph   
com.meyling.principia.logic.rule   
com.meyling.principia.module   
 

Uses of Argument in com.meyling.principia.argument
 

Subinterfaces of Argument in com.meyling.principia.argument
 interface CounterMarker
          An object of this class represents a number.
 

Classes in com.meyling.principia.argument that implement Argument
 class AbstractArgument
          Every Operator must inherit from this class.
 class AbstractArgumentAtom
          Every Atom must inherit from this class.
 class AbstractArgumentList
          Every Operator must inherit from this class.
 class AbstractDynamicArgumentList
          Every Operator with dynamic number of arguments must inherit from this class.
 class Counter
          An object of this class represents a non negative integer.
 class PatternVariable
          Pattern variable, for matching purposes.
 class Text
          An object of this class represents a text string.
 class VariableList
          Dynamic list of arguments.
 

Methods in com.meyling.principia.argument that return Argument
static Argument ArgumentCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
static Argument ArgumentCreator.readArgument(TextInput input, Map string2class, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument FoundException.getLastEntry()
          Get last argument entry.
abstract  Argument AbstractArgument.getArgument(int i)
           
 Argument AbstractArgument.replace(Argument search, Argument replacement)
           
 Argument AbstractArgument.replace(PatternVariables variables)
           
 Argument AbstractArgument.replace(Enumerator counter, int occurance, Argument searchPattern, Argument replacePattern)
           
 Argument AbstractArgument.replaceMatches(Argument searchPattern, Argument replacePattern)
           
abstract  Argument AbstractArgument.create(Argument[] arguments)
           
 Argument AbstractArgumentAtom.getArgument(int i)
           
abstract  Argument AbstractArgumentAtom.copy()
           
 Argument AbstractArgumentAtom.create(Argument[] arguments)
           
 Argument Counter.copy()
           
 Argument Argument.getArgument(int i)
          Get the requested argument.
 Argument Argument.copy()
          Returns an identical object (maybe "this").
 Argument Argument.replace(Argument search, Argument replacement)
          Creates and returns a copy of this object, but replaces anything that equals(java.lang.Object) argument with a copy() of replacement.
 Argument Argument.replace(PatternVariables variables)
          Replace every pattern variable that occurs in variables with its content.
 Argument Argument.replace(Enumerator counter, int occurrence, Argument searchPattern, Argument replacePattern)
          Replace the occurrence-th occurence of searchPattern with replacePattern.
 Argument Argument.replaceMatches(Argument searchPattern, Argument replacePattern)
          Replace all occurrences of searchPattern with replacePattern.
 Argument Argument.create(Argument[] arguments)
          Create a new Argument with given arguments.
 Argument AbstractDynamicArgumentList.getArgument(int i)
           
 Argument AbstractDynamicArgumentList.copy()
           
abstract  Argument AbstractDynamicArgumentList.create(Argument[] arguments)
           
 Argument PatternVariable.getArgument(int i)
           
 Argument PatternVariable.copy()
           
 Argument PatternVariable.getContent()
          Sets argument of pattern variable.
 Argument PatternVariable.create(Argument[] arguments)
           
 Argument VariableList.create(Argument[] arguments)
           
 Argument Text.copy()
           
 Argument AbstractArgumentList.getArgument(int i)
           
 Argument AbstractArgumentList.copy()
           
abstract  Argument AbstractArgumentList.create(Argument[] arguments)
           
 Argument ArgumentException.getArgument()
          Get problematic argument.
 Argument ArgumentException.getSecondaryArgument()
          Get secundary argument.
 

Methods in com.meyling.principia.argument with parameters of type Argument
static Argument ArgumentCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
static void ArgumentCreator.writeArgument(Output output, Argument argument, Map class2string)
          Write an Argument to an Output object.
static String ArgumentCreator.writeArgument(Argument argument, Map class2string)
          Write an Argument to an String.
 void FoundException.addAndThrow(Argument argument)
          Constructs an argument exception, starts with an argument.
 Argument AbstractArgument.replace(Argument search, Argument replacement)
           
 Argument AbstractArgument.replace(Enumerator counter, int occurance, Argument searchPattern, Argument replacePattern)
           
 void AbstractArgument.getSearchParents(Enumerator counter, int occurance, Argument searchPattern)
           
 void AbstractArgument.getReplacementParents(Enumerator counter, int occurance, Argument searchPattern, Argument replacePattern)
           
 Argument AbstractArgument.replaceMatches(Argument searchPattern, Argument replacePattern)
           
 boolean AbstractArgument.matches(Argument pattern, PatternVariables variables)
           
 boolean AbstractArgument.matches(Argument pattern)
           
abstract  Argument AbstractArgument.create(Argument[] arguments)
           
static int AbstractArgument.getHighestNumber(Argument argument)
          Find the highest value for a Counter in this argument.
 Argument AbstractArgumentAtom.create(Argument[] arguments)
           
 Argument Argument.replace(Argument search, Argument replacement)
          Creates and returns a copy of this object, but replaces anything that equals(java.lang.Object) argument with a copy() of replacement.
 Argument Argument.replace(Enumerator counter, int occurrence, Argument searchPattern, Argument replacePattern)
          Replace the occurrence-th occurence of searchPattern with replacePattern.
 void Argument.getSearchParents(Enumerator counter, int occurence, Argument searchPattern)
          Get a children parents list for the occurrence-th occurence of searchPattern.
 void Argument.getReplacementParents(Enumerator counter, int occurence, Argument searchPattern, Argument replacementPattern)
          Get a children parents list for the occurrence-th occurence of searchPattern replaced by replacementPattern.
 Argument Argument.replaceMatches(Argument searchPattern, Argument replacePattern)
          Replace all occurrences of searchPattern with replacePattern.
 boolean Argument.matches(Argument pattern, PatternVariables variables)
          Does this argument match the pattern?
 boolean Argument.matches(Argument pattern)
          Does any part of this argument match the pattern?
 Argument Argument.create(Argument[] arguments)
          Create a new Argument with given arguments.
 void AbstractDynamicArgumentList.add(Argument argument)
          Adds an argument to end of dynamic list.
 void AbstractDynamicArgumentList.insert(int position, Argument argument)
          Inserts an argument to spezified position.
 void AbstractDynamicArgumentList.replace(int position, Argument argument)
          Replaces an argument at spezified position.
abstract  Argument AbstractDynamicArgumentList.create(Argument[] arguments)
           
 void PatternVariable.setContent(Argument content)
          Sets argument of pattern variable.
 Argument PatternVariable.create(Argument[] arguments)
           
 boolean PatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument VariableList.create(Argument[] arguments)
           
abstract  Argument AbstractArgumentList.create(Argument[] arguments)
           
 void ArgumentException.setArgument(Argument argument)
          Set the problematic argument.
 

Constructors in com.meyling.principia.argument with parameters of type Argument
FoundException(Argument argument)
          Constructs an argument exception, starts with an argument.
AbstractDynamicArgumentList(Argument[] arguments)
          Constructs an argument list.
PatternVariable(Argument[] arguments)
          Constructs a pattern variable.
VariableList(Argument[] arguments)
          Constructs a dynamic list of arguments.
AbstractArgumentList(Argument[] arguments)
          Constructs an argument list.
ArgumentException(int code, String description, Argument argument)
          Constructs an argument exception.
ArgumentException(int code, String description, Argument argument, Argument secundaryArgument)
          Constructs an argument exception.
ArgumentException(int code, String description, Argument argument, boolean begin)
          Constructs an argument exception.
 

Uses of Argument in com.meyling.principia.html
 

Methods in com.meyling.principia.html with parameters of type Argument
 void Module2Html.writeFormula(Argument argument, Output output)
          Convert a Formula or its sub arguments into html.
 

Uses of Argument in com.meyling.principia.io
 

Methods in com.meyling.principia.io that return Argument
 Argument ArgumentPointer.getArgument()
          Get wrapped argument.
 

Methods in com.meyling.principia.io with parameters of type Argument
 Position ParsingTable.get(Argument argument)
          Get position of argument.
 void ParsingTable.put(Argument argument, Position position)
          Put argument position.
 

Constructors in com.meyling.principia.io with parameters of type Argument
ArgumentPointer(Argument argument)
          Constructs an marker for begin and end position.
 

Uses of Argument in com.meyling.principia.latex
 

Methods in com.meyling.principia.latex with parameters of type Argument
 void Module2Latex.writeFormula(Argument argument, Output output)
          Convert a Formula or its sub arguments into html.
 

Uses of Argument in com.meyling.principia.logic.basic
 

Subinterfaces of Argument in com.meyling.principia.logic.basic
 interface Formula
          This interface tells us about the methods a Formula must have.
 interface SubjectVariableMarker
          Implementions of this marker interface are threated as subject variables.
 

Classes in com.meyling.principia.logic.basic that implement Argument
 class AbstractFormula
          From this abstract implementation of Formula each non abstract Formula must inherit from.
 class BasicFormulaPatternVariable
          Pattern variable, for matching purposes.
 class BasicPatternVariable
          Pattern variable, for matching purposes.
 class BasicPredicateVariablePatternVariable
          Pattern variable, for matching purposes.
 class BasicSubjectVariablePatternVariable
          Pattern variable, for matching purposes.
 class Conjunction
          Conjunction of formulas.
 class Disjunction
          Disjunction of formulas.
 class Equivalence
          Equivalence of formulas.
 class ExistentialQuantifier
          Existential quantifier, logical "exists".
 class Implication
          Implication of formulas.
 class LogicalOperatorWithTwoFormulas
          LogicalOperatorWithTwoFormulas of formulas.
 class Negation
          Logical negation, logical "not".
 class PredicateVariable
          Predicate variable with argument list.
 class PropositionVariable
          Represents an arbitrary logical proposition.
 class Quantifier
          Basis class for Quantifier.
 class RegularArgumentList
          A simple collection of arguments.
 class SubjectVariable
          Subject variable, represents a subject of the universe of discourse.
 class UniversalQuantifier
          Universal qualifier, logical "for all".
 

Methods in com.meyling.principia.logic.basic that return Argument
 Argument Equivalence.create(Argument[] arguments)
           
 Argument BasicSubjectVariablePatternVariable.create(Argument[] arguments)
           
 Argument PropositionVariable.create(Argument[] arguments)
           
static Argument BasicCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument RegularArgumentList.create(Argument[] arguments)
           
 Argument UniversalQuantifier.create(Argument[] arguments)
           
 Argument BasicPatternVariable.create(Argument[] arguments)
           
 Argument ExistentialQuantifier.create(Argument[] arguments)
           
 Argument Disjunction.create(Argument[] arguments)
           
 Argument Conjunction.create(Argument[] arguments)
           
 Argument BasicPredicateVariablePatternVariable.create(Argument[] arguments)
           
 Argument PredicateVariable.create(Argument[] arguments)
           
 Argument Implication.create(Argument[] arguments)
           
 Argument Negation.create(Argument[] arguments)
           
 Argument SubjectVariable.create(Argument[] arguments)
           
 Argument BasicFormulaPatternVariable.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.basic with parameters of type Argument
 Argument Equivalence.create(Argument[] arguments)
           
 boolean BasicSubjectVariablePatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicSubjectVariablePatternVariable.create(Argument[] arguments)
           
 Argument PropositionVariable.create(Argument[] arguments)
           
static void BasicCreator.writeArgument(Output output, Argument argument)
          Write an Argument to an Output object.
static String BasicCreator.writeArgument(Argument argument)
          Write an Argument to an String.
 Argument RegularArgumentList.create(Argument[] arguments)
           
static void PackageTest.testArgument(Argument argument, StringBuffer list)
          Performes simple argument tests: is argument equal to itself is argument equal to argument.copy() (both directions) is argument equal to same argument created of list with BasicCreator.readArgument(com.meyling.principia.io.TextInput, com.meyling.principia.io.ParsingTable) (both directions) is argument equal to same argument created of result of BasicCreator.writeArgument(com.meyling.principia.io.Output, com.meyling.principia.argument.Argument) with BasicCreator.readArgument(com.meyling.principia.io.TextInput, com.meyling.principia.io.ParsingTable) (both directions)
 Argument UniversalQuantifier.create(Argument[] arguments)
           
 Argument BasicPatternVariable.create(Argument[] arguments)
           
 Argument ExistentialQuantifier.create(Argument[] arguments)
           
 Argument Disjunction.create(Argument[] arguments)
           
 Argument Conjunction.create(Argument[] arguments)
           
 boolean BasicPredicateVariablePatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicPredicateVariablePatternVariable.create(Argument[] arguments)
           
 Argument PredicateVariable.create(Argument[] arguments)
           
 Argument Implication.create(Argument[] arguments)
           
 Argument Negation.create(Argument[] arguments)
           
 Argument SubjectVariable.create(Argument[] arguments)
           
 boolean BasicFormulaPatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicFormulaPatternVariable.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.logic.basic with parameters of type Argument
AbstractFormula(Argument[] arguments)
          Constructs an formula.
LogicalOperatorWithTwoFormulas(Argument[] arguments)
          Constructs a new formula out of two given ones.
Equivalence(Argument[] arguments)
          Constructs a logical equivalence.
BasicSubjectVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
PropositionVariable(Argument[] arguments)
          Constructs a proposition variable.
RegularArgumentList(Argument[] arguments)
          Constructs an argument list.
Quantifier(Argument[] arguments)
          Constructs a logical quantifier.
UniversalQuantifier(Argument[] arguments)
          Constructs a logical universial quantifier.
BasicPatternVariable(Argument[] arguments)
          Constructs a pattern variable.
ExistentialQuantifier(Argument[] arguments)
          Constructs a logical existential quantifier.
Disjunction(Argument[] arguments)
          Constructs a logical disjunction.
Conjunction(Argument[] arguments)
          Constructs a logical conjunction.
BasicPredicateVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
PredicateVariable(Argument[] arguments)
          Constructs a predicate variable with an argument list.
Implication(Argument[] arguments)
          Constructs a logical implication.
Negation(Argument[] arguments)
          Constructs negation of first argument.
SubjectVariable(Argument[] arguments)
          Constructs certain subject variable.
BasicFormulaPatternVariable(Argument[] arguments)
          Constructs a pattern variable.
 

Uses of Argument in com.meyling.principia.logic.paragraph
 

Subinterfaces of Argument in com.meyling.principia.logic.paragraph
 interface ParagraphCheck
          Every main Paragraph entry must implement this interface.
 

Classes in com.meyling.principia.logic.paragraph that implement Argument
 class Abbreviation
          Abbreviation.
 class Axiom
          Logical Axiom.
 class LinkLabel
          A reference label.
 class Paragraph
          A paragraph is an axiom, an abbreviation or a proposition of a mathematical theory.
 class ProofLine
          A proof line of a mathematical proof.
 class ProofLineList
          List of proof lines.
 class Proposition
          Logical Sentence.
 class RuleDeclaration
          Declares a logical rule.
 class Sentence
          Logical Sentence.
 

Methods in com.meyling.principia.logic.paragraph that return Argument
static Argument ParagraphCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument Paragraph.create(Argument[] arguments)
           
 Argument LinkLabel.create(Argument[] arguments)
           
 Argument ProofLine.create(Argument[] arguments)
           
 Argument RuleDeclaration.create(Argument[] arguments)
           
 Argument Axiom.create(Argument[] arguments)
           
 Argument Proposition.create(Argument[] arguments)
           
 Argument ProofLineList.create(Argument[] arguments)
           
 Argument Sentence.create(Argument[] arguments)
           
 Argument Abbreviation.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.paragraph with parameters of type Argument
static void ParagraphCreator.writeArgument(Output output, Argument argument)
          Write an Argument to an Output object.
static String ParagraphCreator.writeArgument(Argument argument)
          Write an Argument to an String.
 Argument Paragraph.create(Argument[] arguments)
           
 Argument LinkLabel.create(Argument[] arguments)
           
 Argument ProofLine.create(Argument[] arguments)
           
 Argument RuleDeclaration.create(Argument[] arguments)
           
 Argument Axiom.create(Argument[] arguments)
           
 Argument Proposition.create(Argument[] arguments)
           
 Argument ProofLineList.create(Argument[] arguments)
           
 Argument Sentence.create(Argument[] arguments)
           
 Argument Abbreviation.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.logic.paragraph with parameters of type Argument
Paragraph(Argument[] arguments)
          Constructs a paragraph.
LinkLabel(Argument[] arguments)
          Constructs a reference label.
ProofLine(Argument[] arguments)
          Constructs a proof line made of a formula and a rule.
RuleDeclaration(Argument[] arguments)
          Constructs a mathematical RuleDeclaration.
Axiom(Argument[] arguments)
          Constructs a logical Axiom.
Proposition(Argument[] arguments)
          Constructs a mathematical proposition with its proof.
ProofLineList(Argument[] arguments)
          Constructs a list of proof lines.
Sentence(Argument[] arguments)
          Constructs a mathematical sentence.
Abbreviation(Argument[] arguments)
          Constructs a definition..
 

Uses of Argument in com.meyling.principia.logic.rule
 

Subinterfaces of Argument in com.meyling.principia.logic.rule
 interface Rule
          Every logical rule must implement this interface.
 

Classes in com.meyling.principia.logic.rule that implement Argument
 class AddAxiom
          Implementation of adding an Axiom: --------- A0
 class AddSentence
          Implemention of adding an Sentence: --------- A0
 class ApplyAxiom
          Implementation of applying an Axiom: A1 => A2 A3 --------- A4 if A1 => A2 matches A3 => A4
 class ApplySentence
          Implementation of applying a Sentence: A1 => A2 A3 --------- A4 if A1 => A2 matches A3 => A4
 class ConjunctionRule
          Implemention of conjunction rule: A1 A2 --------- A1 & A2
 class ElementaryEquivalence
          Implemention of using an elementary equivalence: a => b b => a A(a) --------- A(b)
 class Generalization
          Implemention of making a conclusion universal.
 class HypotheticalSyllogism
          Implemention of (pure) Hypothetical Syllogism: A1 => A2 A2 => A3 --------- A1 => A3
 class LeftAddition
          Implemention of "addition" on the left side.
 class LeftAdditionConjunction
          Implemention of "addition" of an conjunction on the left side.
 class LeftAdditionEquivalence
          Implemention of "addition" of an equivalence on the left side.
 class LeftAdditionImplication
          Implemention of "addition" of an implication on the left side.
 class LinkReference
          A reference label.
 class ModusPonens
          Implemention of Modus Ponens: A0 A0 => A1 --------- A1
 class Particularization
          Implemention of making a conclusion special.
 class RenameBoundSubjectVariable
          Replace a free subject variable by another subject variable: A[x] ----------- A[y]
 class RenameFreeSubjectVariable
          Replace a free subject variable by another subject variable: A[x] x is free in A[x] y is not bound in A[x] ---------------------- A[y]
 class ReplacePredicateVariable
          Replace predicate variable by formula: A[R(x,y,z)] formula F(x,y,z) ------------------ A[F(x,y,z)]
 class ReplacePropositionVariable
          Replace predicate variables by formulas: A[p] formula F ----------- A[F]
 class ReverseAbbreviation
          Implemention of reversing an abbreviation: A1 --------- A0
 class ReverseImplication
          Implemention of reversing an implication.
 class RightAddition
          Implemention of "addition" on the right side.
 class RightAdditionConjunction
          Implemention of "addition" of an conjunction on the left side.
 class RightAdditionEquivalence
          Implemention of "addition" of an equivalence on the right side.
 class RightAdditionImplication
          Implemention of "addition" of an implication on the left side.
 class SubstLine
          Implementation of substituting variables: A1 --------- A2 if A1 matches A2 (e.g.
 class UseAbbreviation
          Implemention of using an abbreviation for a formula: A1 --------- A2
 

Methods in com.meyling.principia.logic.rule that return Argument
 Argument LinkReference.create(Argument[] arguments)
           
 Argument UseAbbreviation.create(Argument[] arguments)
           
static Argument RuleCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument Particularization.create(Argument[] arguments)
           
 Argument ReplacePropositionVariable.create(Argument[] arguments)
           
 Argument RightAdditionEquivalence.create(Argument[] arguments)
           
 Argument LeftAdditionImplication.create(Argument[] arguments)
           
 Argument RenameBoundSubjectVariable.create(Argument[] arguments)
           
 Argument RightAddition.create(Argument[] arguments)
           
 Argument SubstLine.create(Argument[] arguments)
           
 Argument Generalization.create(Argument[] arguments)
           
 Argument LeftAdditionEquivalence.create(Argument[] arguments)
           
 Argument ConjunctionRule.create(Argument[] arguments)
           
 Argument RenameFreeSubjectVariable.create(Argument[] arguments)
           
 Argument RightAdditionConjunction.create(Argument[] arguments)
           
 Argument ReplacePredicateVariable.create(Argument[] arguments)
           
 Argument ReverseImplication.create(Argument[] arguments)
           
 Argument AddSentence.create(Argument[] arguments)
           
 Argument AddAxiom.create(Argument[] arguments)
           
 Argument ApplySentence.create(Argument[] arguments)
           
 Argument ModusPonens.create(Argument[] arguments)
           
 Argument ApplyAxiom.create(Argument[] arguments)
           
 Argument HypotheticalSyllogism.create(Argument[] arguments)
           
 Argument LeftAdditionConjunction.create(Argument[] arguments)
           
 Argument ReverseAbbreviation.create(Argument[] arguments)
           
 Argument RightAdditionImplication.create(Argument[] arguments)
           
 Argument LeftAddition.create(Argument[] arguments)
           
 Argument ElementaryEquivalence.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.rule with parameters of type Argument
 Argument LinkReference.create(Argument[] arguments)
           
 Argument UseAbbreviation.create(Argument[] arguments)
           
static void RuleCreator.writeArgument(Output output, Argument argument)
          Write an Argument to an Output object.
static String RuleCreator.writeArgument(Argument argument)
          Write an Argument to an String.
 Argument Particularization.create(Argument[] arguments)
           
 Argument ReplacePropositionVariable.create(Argument[] arguments)
           
 Argument RightAdditionEquivalence.create(Argument[] arguments)
           
 Argument LeftAdditionImplication.create(Argument[] arguments)
           
 Argument RenameBoundSubjectVariable.create(Argument[] arguments)
           
 Argument RightAddition.create(Argument[] arguments)
           
 Argument SubstLine.create(Argument[] arguments)
           
 Argument Generalization.create(Argument[] arguments)
           
 Argument LeftAdditionEquivalence.create(Argument[] arguments)
           
 Argument ConjunctionRule.create(Argument[] arguments)
           
 Argument RenameFreeSubjectVariable.create(Argument[] arguments)
           
 Argument RightAdditionConjunction.create(Argument[] arguments)
           
 Argument ReplacePredicateVariable.create(Argument[] arguments)
           
 Argument ReverseImplication.create(Argument[] arguments)
           
 Argument AddSentence.create(Argument[] arguments)
           
 Argument AddAxiom.create(Argument[] arguments)
           
 Argument ApplySentence.create(Argument[] arguments)
           
 Argument ModusPonens.create(Argument[] arguments)
           
 Argument ApplyAxiom.create(Argument[] arguments)
           
 Argument HypotheticalSyllogism.create(Argument[] arguments)
           
 Argument LeftAdditionConjunction.create(Argument[] arguments)
           
 Argument ReverseAbbreviation.create(Argument[] arguments)
           
 Argument RightAdditionImplication.create(Argument[] arguments)
           
 Argument LeftAddition.create(Argument[] arguments)
           
 Argument ElementaryEquivalence.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.logic.rule with parameters of type Argument
LinkReference(Argument[] arguments)
          Constructs a reference label.
UseAbbreviation(Argument[] arguments)
          Constructs an abbreviation rule.
Particularization(Argument[] arguments)
          Constructs a particularization rule.
ReplacePropositionVariable(Argument[] arguments)
          Constructs a replace sentence variable rule.
RightAdditionEquivalence(Argument[] arguments)
          Constructs a left implication addition rule.
LeftAdditionImplication(Argument[] arguments)
          Constructs a left implication addition rule.
RenameBoundSubjectVariable(Argument[] arguments)
          Constructs a replace predicate variable rule.
RightAddition(Argument[] arguments)
          Constructs a right addition rule.
SubstLine(Argument[] arguments)
          Constructs an subst line rule by a proof line reference.
Generalization(Argument[] arguments)
          Constructs a generalization rule.
LeftAdditionEquivalence(Argument[] arguments)
          Constructs a left implication addition rule.
ConjunctionRule(Argument[] arguments)
          Constructs a conjunction rule.
RenameFreeSubjectVariable(Argument[] arguments)
          Constructs a replace predicate variable rule.
RightAdditionConjunction(Argument[] arguments)
          Constructs a right conjunction addition rule.
ReplacePredicateVariable(Argument[] arguments)
          Constructs a replace predicate variable rule.
ReverseImplication(Argument[] arguments)
          Constructs a reverse implication rule.
AddSentence(Argument[] arguments)
          Constructs an add sentence rule by a sentence reference.
AddAxiom(Argument[] arguments)
          Constructs an add axiom rule by an axiom reference.
ApplySentence(Argument[] arguments)
          Constructs an apply sentence rule by a proof line reference and a sentence reference.
ModusPonens(Argument[] arguments)
          Constructs a modus ponens rule.
ApplyAxiom(Argument[] arguments)
          Constructs an apply axiom rule by a proof line reference and an axiom reference.
HypotheticalSyllogism(Argument[] arguments)
          Constructs a hypothetical syllogism rule.
LeftAdditionConjunction(Argument[] arguments)
          Constructs a left conjunction addition rule.
ReverseAbbreviation(Argument[] arguments)
          Constructs an inverting abbreviation rule.
RightAdditionImplication(Argument[] arguments)
          Constructs a right implication addition rule.
LeftAddition(Argument[] arguments)
          Constructs a left addition rule.
ElementaryEquivalence(Argument[] arguments)
          Constructs an elementary equivalence rule by two sentence references and an occurence number.
 

Uses of Argument in com.meyling.principia.module
 

Subinterfaces of Argument in com.meyling.principia.module
 interface Labeled
          Every labeled thing must implement this interface.
 interface Textable
          Every thing that represent a kind of text data must implement this interface.
 

Classes in com.meyling.principia.module that implement Argument
 class Author
          Describes a module author.
 class AuthorList
          List of module authors .
 class Description
          A module description.
 class Email
          An email address.
 class Header
          header of a module.
 class Headline
          A module headline.
 class Import
          Describes an import of a module.
 class ImportList
          List of Imports.
 class Location
          Describes the "physical" location of a module for example a directory.
 class LocationList
          List of locations where a module could be found.
 class Module
          Main data object of this project.
 class Name
          A reference label.
 class ParagraphList
          List of Paragraphs
 class Specification
          Describes a specificiation of a module, that means its name, versions and possible "physical" locations.
 class UsedbyList
          List of known references to a module.
 class Version
          A version description.
 

Methods in com.meyling.principia.module that return Argument
 Argument Author.create(Argument[] arguments)
           
 Argument Email.create(Argument[] arguments)
           
 Argument Module.getLabeledArgument(String label)
          Get the sentence or axiom with label label.
 Argument Module.create(Argument[] arguments)
           
 Argument Description.create(Argument[] arguments)
           
 Argument ImportList.create(Argument[] arguments)
           
static Argument ModuleCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
 Argument ModuleCreator.readArgument()
          Create an Argument out of an TextInput object.
 Argument Location.create(Argument[] arguments)
           
 Argument Name.create(Argument[] arguments)
           
 Argument AuthorList.create(Argument[] arguments)
           
static Argument SimpleModuleCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument Version.create(Argument[] arguments)
           
 Argument Header.create(Argument[] arguments)
           
 Argument UsedbyList.create(Argument[] arguments)
           
 Argument LocationList.create(Argument[] arguments)
           
 Argument Import.create(Argument[] arguments)
           
 Argument Headline.create(Argument[] arguments)
           
 Argument Specification.create(Argument[] arguments)
           
 Argument ParagraphList.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.module with parameters of type Argument
 Argument Author.create(Argument[] arguments)
           
 Argument Email.create(Argument[] arguments)
           
 Argument Module.create(Argument[] arguments)
           
 Argument Description.create(Argument[] arguments)
           
 Argument ImportList.create(Argument[] arguments)
           
static Argument ModuleCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
static void ModuleCreator.writeArgument(Output output, Argument argument)
          Write an Argument to an Output object.
static String ModuleCreator.writeArgument(Argument argument)
          Write an Argument to an String.
 Argument Location.create(Argument[] arguments)
           
 Argument Name.create(Argument[] arguments)
           
 Argument AuthorList.create(Argument[] arguments)
           
static void SimpleModuleCreator.writeArgument(Output output, Argument argument)
          Write an Argument to an Output object.
static String SimpleModuleCreator.writeArgument(Argument argument)
          Write an Argument to an String.
 Argument Version.create(Argument[] arguments)
           
 Argument Header.create(Argument[] arguments)
           
 Argument UsedbyList.create(Argument[] arguments)
           
 Argument LocationList.create(Argument[] arguments)
           
static void ModuleWriter.writeFormula(int level, Argument argument, Output output)
          Write a formula (or its sub arguments) into an output.
 Argument Import.create(Argument[] arguments)
           
 Argument Headline.create(Argument[] arguments)
           
 Argument Specification.create(Argument[] arguments)
           
static void PackageTest.testArgument(Argument argument, StringBuffer list)
          Performes simple argument tests: is argument equal to itself is argument equal to argument.copy() (both directions) is argument equal to same argument created of list with ModuleCreator.readArgument() (both directions) is argument equal to same argument created of result of ModuleCreator.writeArgument(com.meyling.principia.io.Output, com.meyling.principia.argument.Argument) with ModuleCreator.readArgument() (both directions)
 Argument ParagraphList.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.module with parameters of type Argument
Author(Argument[] arguments)
          Constructs a proof line made of a formula and a rule and its arguments.
Email(Argument[] arguments)
          Constructs a module description.
Module(Argument[] arguments)
          Constructs a module.
Module(Argument[] arguments, ModuleAddress moduleAddress)
          Constructs a module and verifies it.
Description(Argument[] arguments)
          Constructs a module description.
ImportList(Argument[] arguments)
          Constructs a list of module imports.
Location(Argument[] arguments)
          Constructs a location description for a module.
Name(Argument[] arguments)
          Constructs a module name.
AuthorList(Argument[] arguments)
          Constructs a list of module authors.
Version(Argument[] arguments)
          Constructs a version description.
Header(Argument[] arguments)
          Constructs a module header.
UsedbyList(Argument[] arguments)
          Constructs a list of locations.
LocationList(Argument[] arguments)
          Constructs a list of locations.
Import(Argument[] arguments)
          Constructs an import description.
Headline(Argument[] arguments)
          Constructs a module headline.
Specification(Argument[] arguments)
          Constructs a module specification.
ParagraphList(Argument[] arguments)
          Constructs a list of paragraphs.
 


PMII - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.