Uses of Interface com.meyling.principia.argument.Argument (PMII - Principia Mathematica II)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Hilbert II - JAVA-Packages - Principia Mathematica II
PREV NEXT | FRAMES NO FRAMES

## 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 `Import`s.
`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 `Paragraph`s
`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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Hilbert II - JAVA-Packages - Principia Mathematica II
PREV NEXT | FRAMES NO FRAMES

©left GNU General Public Licence All Rights Reserved.