Hilbert II - 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 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)
           
 


Hilbert II - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.