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

## Uses of Interface
com.meyling.principia.logic.rule.Rule

Packages that use Rule
com.meyling.principia.logic.rule |

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

Classes in com.meyling.principia.logic.rule that implement 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` | `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`

Methods in com.meyling.principia.logic.rule that return Rule
`Rule` | `LeftAdditionConjunction.changeProofLines(int[] mapping)`
`Rule` | `RenameFreeSubjectVariable.changeProofLines(int[] mapping)`
`Rule` | `ConjunctionRule.changeProofLines(int[] mapping)`
`Rule` | `SubstLine.changeProofLines(int[] mapping)`
`Rule` | `ReplacePropositionVariable.changeProofLines(int[] mapping)`
`Rule` | `ReverseImplication.changeProofLines(int[] mapping)`
`Rule` | `Rule.changeProofLines(int[] mapping)` Get proof line numbers that are used to derive the new formula.
`Rule` | `RightAddition.changeProofLines(int[] mapping)`
`Rule` | `AddSentence.changeProofLines(int[] mapping)`
`Rule` | `LeftAddition.changeProofLines(int[] mapping)`
`Rule` | `RightAdditionImplication.changeProofLines(int[] mapping)`
`Rule` | `LeftAdditionImplication.changeProofLines(int[] mapping)`
`Rule` | `ReplacePredicateVariable.changeProofLines(int[] mapping)`
`Rule` | `RenameBoundSubjectVariable.changeProofLines(int[] mapping)`
`Rule` | `AddAxiom.changeProofLines(int[] mapping)`
`Rule` | `Generalization.changeProofLines(int[] mapping)`
`Rule` | `Particularization.changeProofLines(int[] mapping)`
`Rule` | `ApplySentence.changeProofLines(int[] mapping)`
`Rule` | `ApplyAxiom.changeProofLines(int[] mapping)`
`Rule` | `HypotheticalSyllogism.changeProofLines(int[] mapping)`
`Rule` | `ReverseAbbreviation.changeProofLines(int[] mapping)`
`Rule` | `ElementaryEquivalence.changeProofLines(int[] mapping)`
`Rule` | `UseAbbreviation.changeProofLines(int[] mapping)`
`Rule` | `RightAdditionEquivalence.changeProofLines(int[] mapping)`
`Rule` | `LeftAdditionEquivalence.changeProofLines(int[] mapping)`
`Rule` | `ModusPonens.changeProofLines(int[] mapping)`
`Rule` | `RightAdditionConjunction.changeProofLines(int[] mapping)`

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.