PMII - JAVA-Packages - Principia Mathematica II

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 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 UseAbbreviation.changeProofLines(int[] mapping)
           
 Rule Particularization.changeProofLines(int[] mapping)
           
 Rule ReplacePropositionVariable.changeProofLines(int[] mapping)
           
 Rule RightAdditionEquivalence.changeProofLines(int[] mapping)
           
 Rule LeftAdditionImplication.changeProofLines(int[] mapping)
           
 Rule RenameBoundSubjectVariable.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 SubstLine.changeProofLines(int[] mapping)
           
 Rule Generalization.changeProofLines(int[] mapping)
           
 Rule LeftAdditionEquivalence.changeProofLines(int[] mapping)
           
 Rule ConjunctionRule.changeProofLines(int[] mapping)
           
 Rule RenameFreeSubjectVariable.changeProofLines(int[] mapping)
           
 Rule RightAdditionConjunction.changeProofLines(int[] mapping)
           
 Rule ReplacePredicateVariable.changeProofLines(int[] mapping)
           
 Rule ReverseImplication.changeProofLines(int[] mapping)
           
 Rule AddSentence.changeProofLines(int[] mapping)
           
 Rule AddAxiom.changeProofLines(int[] mapping)
           
 Rule ApplySentence.changeProofLines(int[] mapping)
           
 Rule ModusPonens.changeProofLines(int[] mapping)
           
 Rule ApplyAxiom.changeProofLines(int[] mapping)
           
 Rule HypotheticalSyllogism.changeProofLines(int[] mapping)
           
 Rule LeftAdditionConjunction.changeProofLines(int[] mapping)
           
 Rule ReverseAbbreviation.changeProofLines(int[] mapping)
           
 Rule RightAdditionImplication.changeProofLines(int[] mapping)
           
 Rule LeftAddition.changeProofLines(int[] mapping)
           
 Rule ElementaryEquivalence.changeProofLines(int[] mapping)
           
 


PMII - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.