Uses of Class com.meyling.principia.argument.ArgumentException (PMII - Principia Mathematica II)

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

## Uses of 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.

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

©left GNU General Public Licence All Rights Reserved.