Uses of Class com.meyling.principia.argument.AbstractArgument (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.AbstractArgument

Packages that use AbstractArgument
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 AbstractArgument in com.meyling.principia.argument

Subclasses of AbstractArgument in com.meyling.principia.argument
`class` | `AbstractArgumentAtom` Every Atom must inherit from this class.
`class` | `AbstractArgumentList` Every Operator must inherit from this class.
`class` | `AbstractDynamicArgumentList` Every Operator with dynamic number of arguments must inherit from this class.
`class` | `Counter` An object of this class represents a non negative integer.
`class` | `PatternVariable` Pattern variable, for matching purposes.
`class` | `Text` An object of this class represents a text string.
`class` | `VariableList` Dynamic list of arguments.

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

Subclasses of AbstractArgument in com.meyling.principia.logic.basic
`class` | `AbstractFormula` From this abstract implementation of Formula each non abstract Formula must inherit from.
`class` | `BasicFormulaPatternVariable` Pattern variable, for matching purposes.
`class` | `BasicPatternVariable` Pattern variable, for matching purposes.
`class` | `BasicPredicateVariablePatternVariable` Pattern variable, for matching purposes.
`class` | `BasicSubjectVariablePatternVariable` Pattern variable, for matching purposes.
`class` | `Conjunction` Conjunction of formulas.
`class` | `Disjunction` Disjunction of formulas.
`class` | `Equivalence` Equivalence of formulas.
`class` | `ExistentialQuantifier` Existential quantifier, logical "exists".
`class` | `Implication` Implication of formulas.
`class` | `LogicalOperatorWithTwoFormulas` LogicalOperatorWithTwoFormulas of formulas.
`class` | `Negation` Logical negation, logical "not".
`class` | `PredicateVariable` Predicate variable with argument list.
`class` | `PropositionVariable` Represents an arbitrary logical proposition.
`class` | `Quantifier` Basis class for Quantifier.
`class` | `RegularArgumentList` A simple collection of arguments.
`class` | `SubjectVariable` Subject variable, represents a subject of the universe of discourse.
`class` | `UniversalQuantifier` Universal qualifier, logical "for all".

Uses of AbstractArgument in com.meyling.principia.logic.paragraph

Subclasses of AbstractArgument in com.meyling.principia.logic.paragraph
`class` | `Abbreviation` Abbreviation.
`class` | `Axiom` Logical Axiom.
`class` | `LinkLabel` A reference label.
`class` | `Paragraph` A paragraph contains an axiom, an abbreviation or a proposition of a mathematical theory.
`class` | `ProofLine` A proof line of a mathematical proof.
`class` | `ProofLineList` List of proof lines.
`class` | `Proposition` Logical sentence.
`class` | `RuleDeclaration` Declares a logical rule.
`class` | `Sentence` Logical sentence.

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

Subclasses of AbstractArgument in com.meyling.principia.logic.rule
`class` | `AddAxiom` Implementation of adding an Axiom: `---------` `A0`
`class` | `AddSentence` Implemention of adding an Sentence: `---------` `A0`
`class` | `ApplyAxiom` Implementation of applying an Axiom: `A1 => A2` `A3` `---------` `A4` if A1 => A2 matches A3 => A4
`class` | `ApplySentence` Implementation of applying a Sentence: `A1 => A2` `A3` `---------` `A4` if A1 => A2 matches A3 => A4
`class` | `ConjunctionRule` Implemention of conjunction rule: `A1` `A2` `---------` `A1 & A2`
`class` | `ElementaryEquivalence` Implemention of using an elementary equivalence: `a => b` `b => a` `A(a)` `---------` `A(b)`
`class` | `Generalization` Implemention of making a conclusion universal.
`class` | `HypotheticalSyllogism` Implemention of (pure) Hypothetical Syllogism: `A1 => A2` `A2 => A3` `---------` `A1 => A3`
`class` | `LeftAddition` Implemention of "addition" on the left side.
`class` | `LeftAdditionConjunction` Implemention of "addition" of an conjunction on the left side.
`class` | `LeftAdditionEquivalence` Implemention of "addition" of an equivalence on the left side.
`class` | `LeftAdditionImplication` Implemention of "addition" of an implication on the left side.
`class` | `LinkReference` A reference label.
`class` | `ModusPonens` Implemention of Modus Ponens: `A0` `A0 => A1` `---------` `A1`
`class` | `Particularization` Implemention of making a conclusion special.
`class` | `RenameBoundSubjectVariable` Replace a free subject variable by another subject variable: `A[x]` `-----------` `A[y]`
`class` | `RenameFreeSubjectVariable` Replace a free subject variable by another subject variable: `A[x]` `x is free in A[x]` `y is not bound in A[x]` `----------------------` `A[y]`
`class` | `ReplacePredicateVariable` Replace predicate variable by a formula: `A[R(x,y,z)]` `formula F(x,y,z)` `------------------` `A[F(x,y,z)]`
`class` | `ReplacePropositionVariable` Replace predicate variables by formulas: `A[p]` `formula F` `-----------` `A[F]`
`class` | `ReverseAbbreviation` Implemention of reversing an abbreviation: `A1` `---------` `A0`
`class` | `ReverseImplication` Implemention of reversing an implication.
`class` | `RightAddition` Implemention of "addition" on the right side.
`class` | `RightAdditionConjunction` Implemention of "addition" of an conjunction on the left side.
`class` | `RightAdditionEquivalence` Implemention of "addition" of an equivalence on the right side.
`class` | `RightAdditionImplication` Implemention of "addition" of an implication on the left side.
`class` | `SubstLine` Implementation of substituting variables: `A1` `---------` `A2` if A1 matches A2 (e.g.
`class` | `UseAbbreviation` Implemention of using an abbreviation for a formula: `A1` `---------` `A2`

Uses of AbstractArgument in com.meyling.principia.module

Subclasses of AbstractArgument in com.meyling.principia.module
`class` | `Author` Describes a module author.
`class` | `AuthorList` List of module authors .
`class` | `Description` A module description.
`class` | `Email` An email address.
`class` | `Header` header of a module.
`class` | `Headline` A module headline.
`class` | `Import` Describes an import of a module.
`class` | `ImportList` List of `Import`s.
`class` | `Location` Describes the "physical" location of a module for example a directory.
`class` | `LocationList` List of locations where a module could be found.
`class` | `Module` Main data object of this project.
`class` | `Name` A reference label.
`class` | `ParagraphList` List of `Paragraph`s
`class` | `Specification` Describes a specificiation of a module, that means its name, versions and possible "physical" locations.
`class` | `UsedbyList` List of known references to a module.
`class` | `Version` A version description.

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.