Hilbert II - JAVA-Packages - Principia Mathematica II

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

Packages that use Argument
com.meyling.principia.argument   
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 something that should count as 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
 Argument Text.copy()
           
 Argument AbstractDynamicArgumentList.getArgument(int i)
           
 Argument AbstractDynamicArgumentList.copy()
           
abstract  Argument AbstractDynamicArgumentList.create(Argument[] arguments)
           
 Argument FoundException.getLastEntry()
          Get last argument entry.
 Argument ArgumentException.getArgument()
          Get problematic argument.
 Argument ArgumentException.getSecondaryArgument()
          Get secundary argument.
 Argument PatternVariable.getArgument(int i)
           
 Argument PatternVariable.copy()
           
 Argument PatternVariable.getContent()
          Sets argument of pattern variable.
 Argument PatternVariable.create(Argument[] arguments)
           
 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 Counter.copy()
           
 Argument AbstractArgumentAtom.getArgument(int i)
           
abstract  Argument AbstractArgumentAtom.copy()
           
 Argument AbstractArgumentAtom.create(Argument[] arguments)
           
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 AbstractArgumentList.getArgument(int i)
           
 Argument AbstractArgumentList.copy()
           
abstract  Argument AbstractArgumentList.create(Argument[] arguments)
           
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 VariableList.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.argument with parameters of type Argument
 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 FoundException.addAndThrow(Argument argument)
          Constructs an argument exception, starts with an argument.
 void ArgumentException.setArgument(Argument argument)
          Set the problematic argument.
 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 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.
 Argument AbstractArgumentAtom.create(Argument[] arguments)
           
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.
abstract  Argument AbstractArgumentList.create(Argument[] arguments)
           
 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 VariableList.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.argument with parameters of type Argument
AbstractDynamicArgumentList(Argument[] arguments)
          Constructs an argument list.
FoundException(Argument argument)
          Constructs an argument exception, starts with an argument.
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.
PatternVariable(Argument[] arguments)
          Constructs a pattern variable.
AbstractArgumentList(Argument[] arguments)
          Constructs an argument list.
VariableList(Argument[] arguments)
          Constructs a dynamic list of arguments.
 

Uses of Argument in com.meyling.principia.io
 

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.
 

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 LaTeX.
 

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 BasicFormulaPatternVariable.create(Argument[] arguments)
           
 Argument PropositionVariable.create(Argument[] arguments)
           
 Argument BasicPredicateVariablePatternVariable.create(Argument[] arguments)
           
 Argument Disjunction.create(Argument[] arguments)
           
 Argument Implication.create(Argument[] arguments)
           
 Argument PredicateVariable.create(Argument[] arguments)
           
static Argument BasicCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument BasicSubjectVariablePatternVariable.create(Argument[] arguments)
           
 Argument SubjectVariable.create(Argument[] arguments)
           
 Argument ExistentialQuantifier.create(Argument[] arguments)
           
 Argument Negation.create(Argument[] arguments)
           
 Argument UniversalQuantifier.create(Argument[] arguments)
           
 Argument Equivalence.create(Argument[] arguments)
           
 Argument RegularArgumentList.create(Argument[] arguments)
           
 Argument Conjunction.create(Argument[] arguments)
           
 Argument BasicPatternVariable.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.basic with parameters of type Argument
 boolean BasicFormulaPatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicFormulaPatternVariable.create(Argument[] arguments)
           
 Argument PropositionVariable.create(Argument[] arguments)
           
 boolean BasicPredicateVariablePatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicPredicateVariablePatternVariable.create(Argument[] arguments)
           
 Argument Disjunction.create(Argument[] arguments)
           
 Argument Implication.create(Argument[] arguments)
           
 Argument PredicateVariable.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.
 boolean BasicSubjectVariablePatternVariable.isMatching(Argument argument)
          Is the argument matching the pattern variable?
 Argument BasicSubjectVariablePatternVariable.create(Argument[] arguments)
           
 Argument SubjectVariable.create(Argument[] arguments)
           
 Argument ExistentialQuantifier.create(Argument[] arguments)
           
 Argument Negation.create(Argument[] arguments)
           
 Argument UniversalQuantifier.create(Argument[] arguments)
           
 Argument Equivalence.create(Argument[] arguments)
           
 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 Conjunction.create(Argument[] arguments)
           
 Argument BasicPatternVariable.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.logic.basic with parameters of type Argument
BasicFormulaPatternVariable(Argument[] arguments)
          Constructs a pattern variable.
Quantifier(Argument[] arguments)
          Constructs a logical quantifier.
PropositionVariable(Argument[] arguments)
          Constructs a proposition variable.
BasicPredicateVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
LogicalOperatorWithTwoFormulas(Argument[] arguments)
          Constructs a new formula out of two given ones.
Disjunction(Argument[] arguments)
          Constructs a logical disjunction.
Implication(Argument[] arguments)
          Constructs a logical implication.
AbstractFormula(Argument[] arguments)
          Constructs an formula.
PredicateVariable(Argument[] arguments)
          Constructs a predicate variable with an argument list.
BasicSubjectVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
SubjectVariable(Argument[] arguments)
          Constructs certain subject variable.
ExistentialQuantifier(Argument[] arguments)
          Constructs a logical existential quantifier.
Negation(Argument[] arguments)
          Constructs negation of first argument.
UniversalQuantifier(Argument[] arguments)
          Constructs a logical universial quantifier.
Equivalence(Argument[] arguments)
          Constructs a logical equivalence.
RegularArgumentList(Argument[] arguments)
          Constructs an argument list.
Conjunction(Argument[] arguments)
          Constructs a logical conjunction.
BasicPatternVariable(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 contains 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
 Argument ProofLine.create(Argument[] arguments)
           
 Argument LinkLabel.create(Argument[] arguments)
           
 Argument Axiom.create(Argument[] arguments)
           
 Argument ProofLineList.create(Argument[] arguments)
           
 Argument Sentence.create(Argument[] arguments)
           
 Argument Abbreviation.create(Argument[] arguments)
           
 Argument Paragraph.create(Argument[] arguments)
           
static Argument ParagraphCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument Proposition.create(Argument[] arguments)
           
 Argument RuleDeclaration.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.paragraph with parameters of type Argument
 Argument ProofLine.create(Argument[] arguments)
           
 Argument LinkLabel.create(Argument[] arguments)
           
 Argument Axiom.create(Argument[] arguments)
           
 Argument ProofLineList.create(Argument[] arguments)
           
 Argument Sentence.create(Argument[] arguments)
           
 Argument Abbreviation.create(Argument[] arguments)
           
 Argument Paragraph.create(Argument[] arguments)
           
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 Proposition.create(Argument[] arguments)
           
 Argument RuleDeclaration.create(Argument[] arguments)
           
 

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

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 a 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 LeftAdditionConjunction.create(Argument[] arguments)
           
 Argument RenameFreeSubjectVariable.create(Argument[] arguments)
           
 Argument ConjunctionRule.create(Argument[] arguments)
           
 Argument SubstLine.create(Argument[] arguments)
           
 Argument ReplacePropositionVariable.create(Argument[] arguments)
           
 Argument ReverseImplication.create(Argument[] arguments)
           
 Argument LinkReference.create(Argument[] arguments)
           
 Argument RightAddition.create(Argument[] arguments)
           
 Argument AddSentence.create(Argument[] arguments)
           
 Argument LeftAddition.create(Argument[] arguments)
           
 Argument RightAdditionImplication.create(Argument[] arguments)
           
 Argument LeftAdditionImplication.create(Argument[] arguments)
           
 Argument ReplacePredicateVariable.create(Argument[] arguments)
           
 Argument RenameBoundSubjectVariable.create(Argument[] arguments)
           
 Argument AddAxiom.create(Argument[] arguments)
           
static Argument RuleCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument Generalization.create(Argument[] arguments)
           
 Argument Particularization.create(Argument[] arguments)
           
 Argument ApplySentence.create(Argument[] arguments)
           
 Argument ApplyAxiom.create(Argument[] arguments)
           
 Argument HypotheticalSyllogism.create(Argument[] arguments)
           
 Argument ReverseAbbreviation.create(Argument[] arguments)
           
 Argument ElementaryEquivalence.create(Argument[] arguments)
           
 Argument UseAbbreviation.create(Argument[] arguments)
           
 Argument RightAdditionEquivalence.create(Argument[] arguments)
           
 Argument LeftAdditionEquivalence.create(Argument[] arguments)
           
 Argument ModusPonens.create(Argument[] arguments)
           
 Argument RightAdditionConjunction.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.logic.rule with parameters of type Argument
 Argument LeftAdditionConjunction.create(Argument[] arguments)
           
 Argument RenameFreeSubjectVariable.create(Argument[] arguments)
           
 Argument ConjunctionRule.create(Argument[] arguments)
           
 Argument SubstLine.create(Argument[] arguments)
           
 Argument ReplacePropositionVariable.create(Argument[] arguments)
           
 Argument ReverseImplication.create(Argument[] arguments)
           
 Argument LinkReference.create(Argument[] arguments)
           
 Argument RightAddition.create(Argument[] arguments)
           
 Argument AddSentence.create(Argument[] arguments)
           
 Argument LeftAddition.create(Argument[] arguments)
           
 Argument RightAdditionImplication.create(Argument[] arguments)
           
 Argument LeftAdditionImplication.create(Argument[] arguments)
           
 Argument ReplacePredicateVariable.create(Argument[] arguments)
           
 Argument RenameBoundSubjectVariable.create(Argument[] arguments)
           
 Argument AddAxiom.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 Generalization.create(Argument[] arguments)
           
 Argument Particularization.create(Argument[] arguments)
           
 Argument ApplySentence.create(Argument[] arguments)
           
 Argument ApplyAxiom.create(Argument[] arguments)
           
 Argument HypotheticalSyllogism.create(Argument[] arguments)
           
 Argument ReverseAbbreviation.create(Argument[] arguments)
           
 Argument ElementaryEquivalence.create(Argument[] arguments)
           
 Argument UseAbbreviation.create(Argument[] arguments)
           
 Argument RightAdditionEquivalence.create(Argument[] arguments)
           
 Argument LeftAdditionEquivalence.create(Argument[] arguments)
           
 Argument ModusPonens.create(Argument[] arguments)
           
 Argument RightAdditionConjunction.create(Argument[] arguments)
           
 

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

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 Header.create(Argument[] arguments)
           
 Argument Module.getLabeledArgument(String label)
          Get the sentence or axiom with label label.
 Argument Module.create(Argument[] arguments)
           
 Argument Headline.create(Argument[] arguments)
           
 Argument Location.create(Argument[] arguments)
           
 Argument UsedbyList.create(Argument[] arguments)
           
 Argument LocationList.create(Argument[] arguments)
           
 Argument Email.create(Argument[] arguments)
           
 Argument ParagraphList.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.
static Argument SimpleModuleCreator.readArgument(TextInput input, ParsingTable parsing)
          Create an Argument out of an TextInput object.
 Argument AuthorList.create(Argument[] arguments)
           
 Argument Specification.create(Argument[] arguments)
           
 Argument Version.create(Argument[] arguments)
           
 Argument Name.create(Argument[] arguments)
           
 Argument Import.create(Argument[] arguments)
           
 Argument Author.create(Argument[] arguments)
           
 

Methods in com.meyling.principia.module with parameters of type Argument
 Argument Header.create(Argument[] arguments)
           
 Argument Module.create(Argument[] arguments)
           
 Argument Headline.create(Argument[] arguments)
           
 Argument Location.create(Argument[] arguments)
           
 Argument UsedbyList.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 LocationList.create(Argument[] arguments)
           
 Argument Email.create(Argument[] arguments)
           
 Argument ParagraphList.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.
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 AuthorList.create(Argument[] arguments)
           
 Argument Specification.create(Argument[] arguments)
           
 Argument Version.create(Argument[] arguments)
           
 Argument Name.create(Argument[] arguments)
           
 Argument Import.create(Argument[] arguments)
           
 Argument Author.create(Argument[] arguments)
           
static void ModuleWriter.writeFormula(int level, Argument argument, Output output)
          Write a formula (or its sub arguments) into an output.
 

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


Hilbert II - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.