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)

Defined in Twee.CP

Methods

showsPrec :: Int -> Positions f -> ShowS

show :: Positions f -> String

showList :: [Positions f] -> ShowS

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

Defined in Twee

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)

Defined in Twee.CP

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

Defined in Twee.CP

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

Defined in Twee.CP

Methods

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

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

Integral Depth

Defined in Twee.CP

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

Defined in Twee.CP

Methods

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

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

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

negate :: Depth -> Depth

abs :: Depth -> Depth

signum :: Depth -> Depth

fromInteger :: Integer -> Depth

Ord Depth

Defined in Twee.CP

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

Defined in Twee.CP

Methods

toRational :: Depth -> Rational

Show Depth

Defined in Twee.CP

Methods

showsPrec :: Int -> Depth -> ShowS

show :: Depth -> String

showList :: [Depth] -> ShowS

Has (ActiveRule f) Depth

Defined in Twee

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)

Defined in Twee.CP

Methods

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

pPrint :: CriticalPair f -> Doc

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

Symbolic (CriticalPair f)

Defined in Twee.CP

Associated Types

type ConstantOf (CriticalPair f) :: Type

Methods

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

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

type ConstantOf (CriticalPair f)

Defined in Twee.CP

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 (Proof 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 (Proof f), Has a Id) => a -> a -> Overlap f -> Derivation f

Return a proof for a critical pair.