PMII - 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
static Argument ArgumentCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
 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 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.
abstract  Argument AbstractDynamicArgumentList.create(Argument[] arguments)
           
 Argument PatternVariable.create(Argument[] arguments)
           
 Argument VariableList.create(Argument[] arguments)
           
abstract  Argument AbstractArgumentList.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.argument that throw ArgumentException
Counter(int number)
          Constructs a Number.
PatternVariable(Argument[] arguments)
          Constructs a pattern variable.
 

Uses of ArgumentException in com.meyling.principia.logic.basic
 

Methods in com.meyling.principia.logic.basic that throw ArgumentException
 Formula AbstractFormula.replaceBoundSubjectVariable(Enumerator counter, int occurance, SubjectVariable search, SubjectVariable replacement)
           
 Formula AbstractFormula.replaceBoundSubjectVariables(Enumerator counter)
           
 Argument Equivalence.create(Argument[] arguments)
           
 Argument BasicSubjectVariablePatternVariable.create(Argument[] arguments)
           
 Argument PropositionVariable.create(Argument[] arguments)
           
 Argument RegularArgumentList.create(Argument[] arguments)
           
 Argument UniversalQuantifier.create(Argument[] arguments)
           
 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 BasicPatternVariable.create(Argument[] arguments)
           
 Argument ExistentialQuantifier.create(Argument[] arguments)
           
 Argument Disjunction.create(Argument[] arguments)
           
 Argument Conjunction.create(Argument[] arguments)
           
 Argument BasicPredicateVariablePatternVariable.create(Argument[] arguments)
           
 Argument PredicateVariable.create(Argument[] arguments)
           
 Argument Implication.create(Argument[] arguments)
           
 Argument Negation.create(Argument[] arguments)
           
 Argument SubjectVariable.create(Argument[] arguments)
           
 Argument BasicFormulaPatternVariable.create(Argument[] arguments)
           
 

Constructors in com.meyling.principia.logic.basic that throw ArgumentException
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.
Equivalence(Argument[] arguments)
          Constructs a logical equivalence.
Equivalence(Formula formula1, Formula formula2)
          Constructs a logical equivalence.
BasicSubjectVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
BasicSubjectVariablePatternVariable(int number)
          Constructs a pattern variable.
PropositionVariable(Argument[] arguments)
          Constructs a proposition variable.
PropositionVariable(int number)
          Constructs certain proposition variable.
RegularArgumentList(Argument[] arguments)
          Constructs an argument list.
Quantifier(Argument[] arguments)
          Constructs a logical quantifier.
UniversalQuantifier(Argument[] arguments)
          Constructs a logical universial quantifier.
BasicPatternVariable(Argument[] arguments)
          Constructs a pattern variable.
ExistentialQuantifier(Argument[] arguments)
          Constructs a logical existential quantifier.
Disjunction(Argument[] arguments)
          Constructs a logical disjunction.
Disjunction(Formula formula1, Formula formula2)
          Constructs a logical disjunction.
Conjunction(Argument[] arguments)
          Constructs a logical conjunction.
Conjunction(Formula formula1, Formula formula2)
          Constructs a logical conjunction.
BasicPredicateVariablePatternVariable(Argument[] arguments)
          Constructs a pattern variable.
PredicateVariable(Argument[] arguments)
          Constructs a predicate variable with an argument list.
Implication(Argument[] arguments)
          Constructs a logical implication.
Implication(Formula formula1, Formula formula2)
          Constructs a logical implication.
Negation(Argument[] arguments)
          Constructs negation of first argument.
Negation(Formula formula)
          Constructs negation of formula.
SubjectVariable(Argument[] arguments)
          Constructs certain subject variable.
SubjectVariable(int number)
          Constructs certain subject variable.
BasicFormulaPatternVariable(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
 void Paragraph.check(Module module)
          Check if this paragraph could be added.
 Argument Paragraph.create(Argument[] arguments)
           
 Argument LinkLabel.create(Argument[] arguments)
           
 Argument ProofLine.create(Argument[] arguments)
           
 void RuleDeclaration.check(Module module, String label)
          Check if declaration is correct.
 Argument RuleDeclaration.create(Argument[] arguments)
           
 void ParagraphCheck.check(Module module, String label)
          Check if a paragraph could be added to a module.
 Argument Axiom.create(Argument[] arguments)
           
 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)
           
 Argument ProofLineList.create(Argument[] arguments)
           
 Argument Sentence.create(Argument[] arguments)
           
 Argument Abbreviation.create(Argument[] arguments)
           
 

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

Uses of ArgumentException in com.meyling.principia.logic.rule
 

Methods in com.meyling.principia.logic.rule that throw ArgumentException
 Argument LinkReference.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 Particularization.check(Module module, ProofLineList proofLines, int position, Formula formula)
          Check if proof could be extended with 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 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 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 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 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 Rule.check(Module module, ProofLineList proofLines, int position, Formula formula)
          Check if proof could be extended with formula (using the arguments of rule).
 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 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 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 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 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 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 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)
           
 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 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 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 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 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 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 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 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 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 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 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 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)
           
 

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

Uses of ArgumentException in com.meyling.principia.module
 

Methods in com.meyling.principia.module that throw ArgumentException
(package private) static ModuleAddress[] ModuleAddress.getModulePaths(Module module, Specification spec)
          Get all potential module addresses from a module specifiaction.
 Argument Author.create(Argument[] arguments)
           
 Argument Email.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 Description.create(Argument[] arguments)
           
 Argument ImportList.create(Argument[] arguments)
           
static Argument ModuleCreator.createArgument(Class kind, Argument[] argument)
          Creates a new Argument.
 Argument Location.create(Argument[] arguments)
           
 Argument Name.create(Argument[] arguments)
           
 Argument AuthorList.create(Argument[] arguments)
           
 Argument Version.create(Argument[] arguments)
           
static Module ModuleContext.loadModule(Module module, Specification spec)
          Load a certain module.
 Argument Header.create(Argument[] arguments)
           
 Argument UsedbyList.create(Argument[] arguments)
           
 Argument LocationList.create(Argument[] arguments)
           
 Argument Import.create(Argument[] arguments)
           
 Argument Headline.create(Argument[] arguments)
           
 Argument Specification.create(Argument[] arguments)
           
 Argument ParagraphList.create(Argument[] arguments)
           
 

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


PMII - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.