|
Hilbert II - JAVA-Packages - Principia Mathematica II | ||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of ArgumentException in com.meyling.principia.argument |
Methods in com.meyling.principia.argument that throw ArgumentException | |
abstract Argument |
AbstractDynamicArgumentList.create(Argument[] arguments)
|
Argument |
PatternVariable.create(Argument[] arguments)
|
Argument |
Argument.replace(Argument search,
Argument replacement)
Creates and returns a copy of this object, but replaces anything that Argument.equals(java.lang.Object) argument
with a Argument.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 . |
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 . |
Argument |
Argument.create(Argument[] arguments)
Create a new Argument with given arguments. |
static Argument |
ArgumentCreator.createArgument(Class kind,
Argument[] argument)
Creates a new Argument . |
abstract Argument |
AbstractArgumentList.create(Argument[] arguments)
|
Argument |
AbstractArgument.replace(Argument search,
Argument replacement)
|
Argument |
AbstractArgument.replace(PatternVariables variables)
|
Argument |
AbstractArgument.replace(Enumerator counter,
int occurance,
Argument searchPattern,
Argument replacePattern)
|
void |
AbstractArgument.getReplacementParents(Enumerator counter,
int occurance,
Argument searchPattern,
Argument replacePattern)
|
Argument |
AbstractArgument.replaceMatches(Argument searchPattern,
Argument replacePattern)
|
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 that throw ArgumentException | |
PatternVariable(Argument[] arguments)
Constructs a pattern variable. |
|
Counter(int number)
Constructs a Number . |
Uses of ArgumentException in com.meyling.principia.logic.basic |
Methods in com.meyling.principia.logic.basic that throw ArgumentException | |
Formula |
Formula.replaceBoundSubjectVariable(Enumerator counter,
int occurrence,
SubjectVariable search,
SubjectVariable replacement)
Replace the occurrence -th occurence of a bound
SubjectVariable by another one. |
Formula |
Formula.replaceBoundSubjectVariables(Enumerator counter)
Replace every bound SubjectVariable by a BasicSubjectVariablePatternVariable |
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)
|
Formula |
AbstractFormula.replaceBoundSubjectVariable(Enumerator counter,
int occurance,
SubjectVariable search,
SubjectVariable replacement)
|
Formula |
AbstractFormula.replaceBoundSubjectVariables(Enumerator counter)
|
Argument |
PredicateVariable.create(Argument[] arguments)
|
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)
|
Constructors in com.meyling.principia.logic.basic that throw ArgumentException | |
BasicFormulaPatternVariable(Argument[] arguments)
Constructs a pattern variable. |
|
Quantifier(Argument[] arguments)
Constructs a logical quantifier. |
|
PropositionVariable(Argument[] arguments)
Constructs a proposition variable. |
|
PropositionVariable(int number)
Constructs certain proposition variable. |
|
BasicPredicateVariablePatternVariable(Argument[] arguments)
Constructs a pattern variable. |
|
LogicalOperatorWithTwoFormulas(Argument[] arguments)
Constructs a new formula out of two given ones. |
|
LogicalOperatorWithTwoFormulas(Formula formula1,
Formula formula2)
Constructs a new formula out of two given ones. |
|
Disjunction(Argument[] arguments)
Constructs a logical disjunction. |
|
Disjunction(Formula formula1,
Formula formula2)
Constructs a logical disjunction. |
|
Implication(Argument[] arguments)
Constructs a logical implication. |
|
Implication(Formula formula1,
Formula formula2)
Constructs a logical implication. |
|
PredicateVariable(Argument[] arguments)
Constructs a predicate variable with an argument list. |
|
BasicSubjectVariablePatternVariable(Argument[] arguments)
Constructs a pattern variable. |
|
BasicSubjectVariablePatternVariable(int number)
Constructs a pattern variable. |
|
SubjectVariable(Argument[] arguments)
Constructs certain subject variable. |
|
SubjectVariable(int number)
Constructs certain subject variable. |
|
ExistentialQuantifier(Argument[] arguments)
Constructs a logical existential quantifier. |
|
Negation(Argument[] arguments)
Constructs negation of first argument. |
|
Negation(Formula formula)
Constructs negation of formula. |
|
UniversalQuantifier(Argument[] arguments)
Constructs a logical universial quantifier. |
|
Equivalence(Argument[] arguments)
Constructs a logical equivalence. |
|
Equivalence(Formula formula1,
Formula formula2)
Constructs a logical equivalence. |
|
RegularArgumentList(Argument[] arguments)
Constructs an argument list. |
|
Conjunction(Argument[] arguments)
Constructs a logical conjunction. |
|
Conjunction(Formula formula1,
Formula formula2)
Constructs a logical conjunction. |
|
BasicPatternVariable(Argument[] arguments)
Constructs a pattern variable. |
Uses of ArgumentException in com.meyling.principia.logic.paragraph |
Methods in com.meyling.principia.logic.paragraph that throw ArgumentException | |
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)
|
void |
Paragraph.check(Module module)
Check if this paragraph could be added. |
Argument |
Paragraph.create(Argument[] arguments)
|
void |
ParagraphCheck.check(Module module,
String label)
Check if a paragraph could be added to a module. |
void |
Proposition.check(Module module,
String label)
Check if proof is correct. |
void |
Proposition.compress()
Remove all double and unused proof lines. |
void |
Proposition.reduceRuleVersion(Module module,
Version version)
Reduce needed rule version and change proof lines in that way. |
Argument |
Proposition.create(Argument[] arguments)
|
void |
RuleDeclaration.check(Module module,
String label)
Check if declaration is correct. |
Argument |
RuleDeclaration.create(Argument[] arguments)
|
Constructors in com.meyling.principia.logic.paragraph that throw ArgumentException | |
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 ArgumentException in com.meyling.principia.logic.rule |
Methods in com.meyling.principia.logic.rule that throw ArgumentException | |
void |
LeftAdditionConjunction.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of left addition of a conjunction. |
static void |
LeftAdditionConjunction.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
LeftAdditionConjunction.create(Argument[] arguments)
|
void |
RenameFreeSubjectVariable.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula by replacing a free subject variable of a proof line by another subject variable. |
static void |
RenameFreeSubjectVariable.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
RenameFreeSubjectVariable.create(Argument[] arguments)
|
void |
ConjunctionRule.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of conjunction rule. |
static void |
ConjunctionRule.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ConjunctionRule.create(Argument[] arguments)
|
void |
SubstLine.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula .
|
static void |
SubstLine.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
SubstLine.create(Argument[] arguments)
|
void |
ReplacePropositionVariable.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula if the proposition variable is replaced by the formula of the constructor. |
static void |
ReplacePropositionVariable.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ReplacePropositionVariable.create(Argument[] arguments)
|
void |
ReverseImplication.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of reversing an implication. |
static void |
ReverseImplication.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
ReverseImplication.create(Argument[] arguments)
|
void |
Rule.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula (using the arguments of rule). |
Argument |
LinkReference.create(Argument[] arguments)
|
void |
RightAddition.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition. |
static void |
RightAddition.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
RightAddition.create(Argument[] arguments)
|
void |
AddSentence.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula. |
static void |
AddSentence.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
AddSentence.create(Argument[] arguments)
|
void |
LeftAddition.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of left addition. |
static void |
LeftAddition.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
LeftAddition.create(Argument[] arguments)
|
void |
RightAdditionImplication.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition of a implication. |
static void |
RightAdditionImplication.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
RightAdditionImplication.create(Argument[] arguments)
|
void |
LeftAdditionImplication.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition of a implication. |
static void |
LeftAdditionImplication.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
LeftAdditionImplication.create(Argument[] arguments)
|
void |
ReplacePredicateVariable.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula if replacing the predicate variable by the formula of the constructor. |
static void |
ReplacePredicateVariable.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ReplacePredicateVariable.create(Argument[] arguments)
|
void |
RenameBoundSubjectVariable.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula by replacing a bound subject variable of a proof line by another subject variable at a certain occurance. |
static void |
RenameBoundSubjectVariable.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
RenameBoundSubjectVariable.create(Argument[] arguments)
|
void |
AddAxiom.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula .
|
static void |
AddAxiom.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
AddAxiom.create(Argument[] arguments)
|
void |
Generalization.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of modus ponens. |
static void |
Generalization.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
Generalization.create(Argument[] arguments)
|
void |
Particularization.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with a formula because of modus ponens. |
static void |
Particularization.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
Particularization.create(Argument[] arguments)
|
void |
ApplySentence.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula .
|
static void |
ApplySentence.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ApplySentence.create(Argument[] arguments)
|
void |
ApplyAxiom.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula .
|
static void |
ApplyAxiom.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ApplyAxiom.create(Argument[] arguments)
|
void |
HypotheticalSyllogism.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of hypothetical syllogism. |
static void |
HypotheticalSyllogism.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
HypotheticalSyllogism.create(Argument[] arguments)
|
void |
ReverseAbbreviation.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula. |
static void |
ReverseAbbreviation.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ReverseAbbreviation.create(Argument[] arguments)
|
void |
ElementaryEquivalence.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula. |
static void |
ElementaryEquivalence.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ElementaryEquivalence.create(Argument[] arguments)
|
void |
UseAbbreviation.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula. |
static void |
UseAbbreviation.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
UseAbbreviation.create(Argument[] arguments)
|
void |
RightAdditionEquivalence.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition of a implication. |
static void |
RightAdditionEquivalence.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
RightAdditionEquivalence.create(Argument[] arguments)
|
void |
LeftAdditionEquivalence.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition of a implication. |
static void |
LeftAdditionEquivalence.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
LeftAdditionEquivalence.create(Argument[] arguments)
|
void |
ModusPonens.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of modus ponens. |
static void |
ModusPonens.checkDeclaration(Module module,
RuleDeclaration declaration)
Check this rule could be declared. |
Argument |
ModusPonens.create(Argument[] arguments)
|
void |
RightAdditionConjunction.check(Module module,
ProofLineList proofLines,
int position,
Formula formula)
Check if proof could be extended with formula because of right addition of a conjunction. |
static void |
RightAdditionConjunction.checkDeclaration(Module module,
RuleDeclaration declaration)
Check if this rule could be declared. |
Argument |
RightAdditionConjunction.create(Argument[] arguments)
|
Constructors in com.meyling.principia.logic.rule that throw ArgumentException | |
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 ArgumentException in com.meyling.principia.module |
Methods in com.meyling.principia.module that throw ArgumentException | |
Argument |
Header.create(Argument[] arguments)
|
void |
Module.check()
Verifies this module. |
void |
Module.addRuleDeclaration(String ruleLabel,
RuleDeclaration declaration,
Module module)
Declare a new rule. |
void |
Module.setModuleAddress(ModuleAddress moduleAddress)
Set the URL where this module is from. |
void |
Module.setRuleVersion(Version version)
Set the rule version this module could use maximal. |
Argument |
Module.create(Argument[] arguments)
|
Argument |
Headline.create(Argument[] arguments)
|
Argument |
Location.create(Argument[] arguments)
|
(package private) static ModuleAddress[] |
ModuleAddress.getModulePaths(Module module,
Specification spec)
Get all potential module addresses from a module specifiaction. |
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 |
AuthorList.create(Argument[] arguments)
|
Argument |
Specification.create(Argument[] arguments)
|
Argument |
Version.create(Argument[] arguments)
|
Module |
ModuleContext.loadModule(Module module,
Specification spec)
Load a certain module. |
Argument |
Name.create(Argument[] arguments)
|
Argument |
Import.create(Argument[] arguments)
|
Argument |
Author.create(Argument[] arguments)
|
Constructors in com.meyling.principia.module that throw ArgumentException | |
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. |
|
Version(String version)
Constructs a version description. |
|
Name(Argument[] arguments)
Constructs a module name. |
|
Name(String name)
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. |