Hilbert II - JAVA-Packages - Principia Mathematica II

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 Imports.
 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 Paragraphs
 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.
 


Hilbert II - JAVA-Packages - Principia Mathematica II

©left GNU General Public Licence
All Rights Reserved.