Hilbert II - JAVA-Packages - Principia Mathematica II

Uses of Class
com.meyling.principia.argument.ArgumentException

Packages that use ArgumentException
com.meyling.principia.argument   
com.meyling.principia.logic.basic   
com.meyling.principia.logic.paragraph   
com.meyling.principia.logic.rule   
com.meyling.principia.module   
 

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

©left GNU General Public Licence
All Rights Reserved.