|
Hilbert II - JAVA-Packages - Principia Mathematica II | ||||||||||
PREV NEXT | FRAMES NO FRAMES |
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. |
|
Hilbert II - JAVA-Packages - Principia Mathematica II | ||||||||||
PREV NEXT | FRAMES NO FRAMES |
©left GNU General Public Licence All Rights Reserved. |