Twee.CP

Critical pair generation.

Documentation

data Positions f

The set of positions at which a term can have critical overlaps.

Constructors

NilP

ConsP !Int !(Positions f)

Instances

Show (Positions f)

Methods

showsPrec :: Int -> Positions f -> ShowS

show :: Positions f -> String

showList :: [Positions f] -> ShowS

(~) * f g => Has (ActiveRule f) (Positions g)

Methods

the :: ActiveRule f -> Positions g

type PositionsOf a = Positions (ConstantOf a)

positions :: Term f -> Positions f

Calculate the set of positions for a term.

positionsChurch :: Positions f -> ChurchList Int

data Overlap f

A critical overlap of one rule with another.

Constructors

Overlap

Fields

• overlap_depth :: !Depth

  The depth (1 for CPs of axioms, 2 for CPs whose rules have depth 1, etc.)

• overlap_top :: !(Term f)

  The critical term.

• overlap_inner :: !(Term f)

  The part of the critical term which the inner rule rewrites.

• overlap_pos :: !Int

  The position in the critical term which is rewritten.

• overlap_eqn :: !(Equation f)

  The critical pair itself.

Instances

Show (Overlap f)

Methods

showsPrec :: Int -> Overlap f -> ShowS

show :: Overlap f -> String

showList :: [Overlap f] -> ShowS

type OverlapOf a = Overlap (ConstantOf a)

newtype Depth

Represents the depth of a critical pair.

Constructors

Depth Int

Instances

Enum Depth

Methods

succ :: Depth -> Depth

pred :: Depth -> Depth

toEnum :: Int -> Depth

fromEnum :: Depth -> Int

enumFrom :: Depth -> [Depth]

enumFromThen :: Depth -> Depth -> [Depth]

enumFromTo :: Depth -> Depth -> [Depth]

enumFromThenTo :: Depth -> Depth -> Depth -> [Depth]

Eq Depth

Methods

(==) :: Depth -> Depth -> Bool

(/=) :: Depth -> Depth -> Bool

Integral Depth

Methods

quot :: Depth -> Depth -> Depth

rem :: Depth -> Depth -> Depth

div :: Depth -> Depth -> Depth

mod :: Depth -> Depth -> Depth

quotRem :: Depth -> Depth -> (Depth, Depth)

divMod :: Depth -> Depth -> (Depth, Depth)

toInteger :: Depth -> Integer

Num Depth

Methods

(+) :: Depth -> Depth -> Depth

(-) :: Depth -> Depth -> Depth

(*) :: Depth -> Depth -> Depth

negate :: Depth -> Depth

abs :: Depth -> Depth

signum :: Depth -> Depth

fromInteger :: Integer -> Depth

Ord Depth

Methods

compare :: Depth -> Depth -> Ordering

(<) :: Depth -> Depth -> Bool

(<=) :: Depth -> Depth -> Bool

(>) :: Depth -> Depth -> Bool

(>=) :: Depth -> Depth -> Bool

max :: Depth -> Depth -> Depth

min :: Depth -> Depth -> Depth

Real Depth

Methods

toRational :: Depth -> Rational

Show Depth

Methods

showsPrec :: Int -> Depth -> ShowS

show :: Depth -> String

showList :: [Depth] -> ShowS

Has (ActiveRule f) Depth

Methods

the :: ActiveRule f -> Depth

overlaps :: (Function f, Has a (Rule f), Has a (Positions f), Has a Depth) => Depth -> Index f a -> [a] -> a -> [(a, a, Overlap f)]

Compute all overlaps of a rule with a set of rules.

overlapsChurch :: forall f a. (Function f, Has a (Rule f), Has a (Positions f), Has a Depth) => Depth -> Index f a -> [a] -> a -> ChurchList (a, a, Overlap f)

asymmetricOverlaps :: (Function f, Has a (Rule f), Has a Depth) => Index f a -> Depth -> Positions f -> Rule f -> Rule f -> ChurchList (Overlap f)

overlapAt :: Int -> Depth -> Rule f -> Rule f -> Maybe (Overlap f)

Create an overlap at a particular position in a term. Doesn't simplify the overlap.

simplifyOverlap :: (Function f, Has a (Rule f)) => Index f a -> Overlap f -> Maybe (Overlap f)

Simplify an overlap and remove it if it's trivial.

buildReplacePositionSub :: TriangleSubst f -> Int -> TermList f -> TermList f -> Term f

termSubst :: TriangleSubst f -> Term f -> Term f

data Config

The configuration for the critical pair weighting heuristic.

Constructors

Config

Fields

• cfg_lhsweight :: !Int
• cfg_rhsweight :: !Int
• cfg_funweight :: !Int
• cfg_varweight :: !Int
• cfg_depthweight :: !Int
• cfg_dupcost :: !Int
• cfg_dupfactor :: !Int

defaultConfig :: Config

The default heuristic configuration.

score :: Function f => Config -> Overlap f -> Int

Compute a score for a critical pair.

Higher-level handling of critical pairs.

data CriticalPair f

A critical pair together with information about how it was derived

Constructors

CriticalPair

Fields

• cp_eqn :: !(Equation f)

  The critical pair itself.

• cp_depth :: !Depth

  The depth of the critical pair.

• cp_top :: !(Maybe (Term f))

  The critical term, if there is one. (Axioms do not have a critical term.)

• cp_proof :: !(Derivation f)

  A derivation of the critical pair from the axioms.

Instances

PrettyTerm f => Pretty (CriticalPair f)

Methods

pPrintPrec :: PrettyLevel -> Rational -> CriticalPair f -> Doc

pPrint :: CriticalPair f -> Doc

pPrintList :: PrettyLevel -> [CriticalPair f] -> Doc

Symbolic (CriticalPair f)

Associated Types

type ConstantOf (CriticalPair f) :: *

Methods

termsDL :: CriticalPair f -> DList (TermListOf (CriticalPair f))

subst_ :: (Var -> BuilderOf (CriticalPair f)) -> CriticalPair f -> CriticalPair f

type ConstantOf (CriticalPair f)

type ConstantOf (CriticalPair f) = f

split :: Function f => CriticalPair f -> [CriticalPair f]

Split a critical pair so that it can be turned into rules.

The resulting critical pairs have the property that no variable appears on the right that is not on the left.

makeCriticalPair :: (Has a (Rule f), Has a (Lemma f), Has a Id, Function f) => a -> a -> Overlap f -> Maybe (CriticalPair f)

Make a critical pair from two rules and an overlap.

overlapProof :: forall a f. (Has a (Rule f), Has a (Lemma f), Has a Id) => a -> a -> Overlap f -> Derivation f

Return a proof for a critical pair.