ReplacePredicateVariable (PMII - Principia Mathematica II)
Keywords: com.meyling.principia.logic.rule.ReplacePredicateVariable class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Hilbert II - JAVA-Packages - Principia Mathematica II
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.meyling.principia.logic.rule
Class ReplacePredicateVariable

    java.lang.Object
      com.meyling.principia.argument.AbstractArgument
          com.meyling.principia.argument.AbstractArgumentList
              com.meyling.principia.logic.rule.ReplacePredicateVariable

All Implemented Interfaces:
  Argument, Rule

public class ReplacePredicateVariable
extends AbstractArgumentList
implements Argument, Rule

Replace predicate variable by a formula:

`A[R(x,y,z)]`

`formula F(x,y,z)`

`------------------`

`A[F(x,y,z)]`

Version:
  $Revision: 1.9 $
Author:
  Michael Meyling

Constructor Summary
`ReplacePredicateVariable(Argument[] arguments)` Constructs a replace predicate variable rule.

Method Summary
`Rule` | `changeProofLines(int[] mapping)` Get proof line numbers that are used to derive the new formula.
`void` | `check(Module module, ProofLineList proofLines, int position, Formula formula)` Check if proof could be extended with formula if replacing the predicate variable by the formula of the constructor.
`static void` | `checkDeclaration(Module module, RuleDeclaration declaration)` Check this rule could be declared.
`Argument` | `create(Argument[] arguments)` Create a new Argument with given arguments.
`ProofLineList` | `extendWithout(Module module, ProofLineList proofLines, int position)` Return proof lines that could replace the proof line `position`.
`int[]` | `getProofLines()` Get proof line numbers that are used to derive the new formula.
`Version` | `getVersion()` Get version of this rule.
`String` | `toString()` Get the argument in `String` form.

Methods inherited from class com.meyling.principia.argument.AbstractArgumentList
`copy, getArgument, getArgumentSize`

Methods inherited from class com.meyling.principia.argument.AbstractArgument
`containsPatternVariables, equals, getHighestNumber, getPatternVariables, getReplacementParents, getSearchParents, hashCode, matches, matches, replace, replace, replace, replaceMatches`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface com.meyling.principia.argument.Argument
`containsPatternVariables, copy, equals, getArgument, getArgumentSize, getPatternVariables, getReplacementParents, getSearchParents, hashCode, matches, matches, replace, replace, replace, replaceMatches`

Constructor Detail

### ReplacePredicateVariable

    public ReplacePredicateVariable(Argument[] arguments)
                             throws ArgumentException

  Constructs a replace predicate variable rule.

Parameters:
  `arguments` -
  - 0: Counter as an proof line reference
  - 1: predicate variable, that contains only pattern variables as arguments. All of these pattern variables must be different, so that the number of different pattern variables in the predicate variable formula is equal to the list length of the predicate variable.
  - 2: formula that must have the same pattern variables
Throws:
  `ArgumentException` - if there are not three instances of `Counter`, `PredicateVariable`, `Formula` (in exactly that order) or the restrictions from above are not fullfilled

Method Detail

### check

    public final void check(Module module,
                            ProofLineList proofLines,
                            int position,
                            Formula formula)
                     throws ArgumentException

  Check if proof could be extended with formula if replacing the predicate variable by the formula of the constructor.

  Specified by:
    `check` in interface `Rule`
  Parameters:
    `module` - module
    `proofLines` - proof lines
    `position` - number of proof lines that could be used in the rule
    `formula` - formula to add
  Throws:
    `ArgumentException` - if addition is not possible because the proof line number is not allowed (e.g. between 1 and the minimum of `position` and current maximum proof line number) or the referenced proof line is no formula or the set of free variables of the formula and the set of bound variables of the proof line aren't disjunct or the set of bound variables of the formula and the subject variables of the proof line aren't disjunct or the predicate variable is in reach of an quantor with subject variable x, and x occurs in the replacement formula or the resulting formula is not equal to `formula` or a version conflict occurs

### extendWithout

    public ProofLineList extendWithout(Module module,
                                       ProofLineList proofLines,
                                       int position)
                                throws UnsupportedOperationException

  Description copied from interface: `Rule`
  Return proof lines that could replace the proof line `position`.

  Specified by:
    `extendWithout` in interface `Rule`
  Parameters:
    `module` - the belonging module
    `proofLines` - proof lines
    `position` - referenced proof line (starting with 0) in `proofLines`
  Returns:
    proof lines that could substitute the single proof line `position`
  Throws:
    `UnsupportedOperationException` - if this rule couldn't be reduced at all because it is a basic rule

### getProofLines

    public int[] getProofLines()

  Description copied from interface: `Rule`
  Get proof line numbers that are used to derive the new formula.

  Specified by:
    `getProofLines` in interface `Rule`
  Returns:
    numbers of involved proof lines

### changeProofLines

    public Rule changeProofLines(int[] mapping)

  Description copied from interface: `Rule`
  Get proof line numbers that are used to derive the new formula.

  Specified by:
    `changeProofLines` in interface `Rule`
  Parameters:
    `mapping` - array that maps old proof line numbers (index) to new ones (value)
  Returns:
    same rule but with changed numbers of involved proof lines

### checkDeclaration

    public static final void checkDeclaration(Module module,
                                              RuleDeclaration declaration)
                                       throws ArgumentException

  Check this rule could be declared.

  Parameters:
    `module` - the module context
    `declaration` - the declaration that shall declare this rule
  Throws:
    `IllegalArgumentException` - if an programming error occured
    `ArgumentException` - if declaration failed

### getVersion

    public final Version getVersion()

  Description copied from interface: `Rule`
  Get version of this rule.

  Specified by:
    `getVersion` in interface `Rule`
  Returns:
    rule version

### create

    public final Argument create(Argument[] arguments)
                          throws ArgumentException

  Description copied from interface: `Argument`
  Create a new Argument with given arguments.

  Specified by:
    `create` in interface `Argument`
  Specified by:
    `create` in class `AbstractArgumentList`
  Throws:
    `ArgumentException`

### toString

    public final String toString()

  Description copied from interface: `Argument`
  Get the argument in `String` form.

  Specified by:
    `toString` in interface `Argument`
  Specified by:
    `toString` in class `AbstractArgumentList`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Hilbert II - JAVA-Packages - Principia Mathematica II
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

©left GNU General Public Licence All Rights Reserved.