t(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NoneQV$ENone(  An array.The size of the array.The contents of the array.!A type which has a default value.The default value.3Convert an array to a list of (index, value) pairs.Create an empty array.Index into an array. O(1) time.Update the array. O(n) time. SafeV._A heap.Take the union of two heaps.A singleton heap.The empty heap.Insert an element.$Find and remove the minimum element.>Map a function over a heap, removing all values which map to L. May be more efficient when the function being mapped is mostly monotonic.*Return the number of elements in the heap.None"#V3A value of type a" which has been given a unique ID.The unique ID of a label. Construct a  a' from its unique ID, which must be the  of an already existing . Extremely unsafe!Assign a label to a value.*Recover the underlying value from a label.Safe"#8 A task which runs in the monad m and produces a value of type a. Create a new task that should be run a certain proportion of the time. The first argument is how often in seconds the task should run, at most. The second argument is the maximum percentage of time that should be spent on the task."Run a task if it's time to run it.   None "#%DKQVdRA monoid for building terms. & represents the empty termlist, while  appends two termlists. A variable.rThe variable's number. Don't use huge variable numbers: they will be truncated to 32 bits when stored in a term.A function symbol. fB is the underlying type of function symbols defined by the user;  f is an f8 together with an automatically-generated unique number.The unique number of a . f, is a term whose function symbols have type f. It is either a  or an . f5 is a list of terms whose function symbols have type f. It is either a  or an . You can turn it into a [ f] with .Matches a function application.Matches a variable.Like i, but does not check that the termlist is non-empty. Use only if you are sure the termlist is non-empty.:Matches a non-empty termlist, unpacking it into head and -everything except the root symbol of the head;. Useful for iterating through terms one symbol at a time.For example, if ts is the termlist [f(x,y), g(z)], then let ConsSym u us = ts# results in the following bindings: u = f(x,y) us = [x, y, g(z)]Like i, but does not check that the termlist is non-empty. Use only if you are sure the termlist is non-empty.>Matches a non-empty termlist, unpacking it into head and tail.Matches the empty termlist.Index into a termlist.0The length of (number of symbols in) a termlist.  Construct a  from a function symbol.!$The underlying function symbol of a ."Convert a term to a termlist.#5Is a term contained as a subterm in a given termlist?)Check if a variable occurs in a termlist.=     !"#  None %FTVdC$wA triangle substitution is one in which variables can be defined in terms of each other, though not in a circular way.:The main use of triangle substitutions is in unification; PZ returns one. A triangle substitution can be converted to an ordinary substitution with F, or used directly using its * instance.'5A substitution which maps variables to terms of type  f.*.A class for values which act as substitutions.Instances include '. as well as functions from variables to terms.+(The underlying type of function symbols.,%Apply the substitution to a variable.-%Apply the substitution to a termlist.. Instances of . can be turned into terms using 2 or 3', and turned into term builders using 0C. Has instances for terms, termlists, builders, and Haskell lists./(The underlying type of function symbols.0Convert a value into a .1A pattern which extracts the ! from a .2>Build a term. The given builder must produce exactly one term.3Build a termlist.40Build a constant (a function with no arguments).5Build a function application.6Build a variable.7-Convert a substitution to a list of bindings.8$Fold a function over a substitution.9ACheck if all bindings of a substitution satisfy a given property.:5Compute the set of variables bound by a substitution.;Apply a substitution to a term.<<Return the highest-number variable in a substitution plus 1.=;Look up a variable in a substitution, returning a termlist.>7Add a new binding to a substitution, giving a termlist.?%Remove a binding from a substitution.@FAdd a new binding to a substitution. Overwrites any existing binding.ACompose two substitutions.BcCheck if two substitutions are compatible (they do not send the same variable to different terms).CaTake the union of two substitutions. The substitutions must be compatible, which is not checked.DcCheck if a substitution is idempotent (applying it twice has the same effect as applying it once).E6Check if a substitution has no effect on a given term.F6Iterate a triangle substitution to make it idempotent.GgReturn a substitution which renames the variables of a list of terms to put them in a canonical order.HThe empty substitution.I/Construct a substitution from a list. Returns Nothing3 if a variable is bound to several different terms.JJ pat t matches the term t against the pattern pat.K A variant of J( which extends an existing substitution.L A variant of J which works on termlists.M A variant of J@ which works on termlists and extends an existing substitution.NUnify two terms.OUnify two termlists.PRUnify two terms, returning a triangle substitution. This is slightly faster than N.QVUnify two termlists, returning a triangle substitution. This is slightly faster than N.SThe empty termlist.T-Get the children (direct subterms) of a term.U2Convert a termlist into an ordinary list of terms.V%Look up a variable in a substitution.W$Add a new binding to a substitution.XFind the length of a term.Y<Return the lowest- and highest-numbered variables in a term.Z@Return the lowest- and highest-numbered variables in a termlist.[IReturn the lowest- and highest-numbered variables in a list of termlists.\%Check if a variable occurs in a term.] Find all subterms of a termlist.^Find all subterms of a term._#Find all proper subterms of a term.`*Check if a term is a function application.aCheck if a term is a variablebt `'isInstanceOf'\` pat checks if t is an instance of pat.c0Check if two terms are renamings of one another.d#Is a term a subterm of another one?e3Map a function over the function symbols in a term.f7Map a function over the function symbols in a termlist.gEReplace the term at a given position in a term with a different term.hReplace the term at a given position in a term with a different term, while simultaneously applying a substitution. Useful for building critical pairs.iHConvert a position in a term, expressed as a single number, into a path.j)Convert a path in a term into a position.k Compare the ! s of two s.] !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk^`a"XSU !1./023456T_]^\d#*+,-;'()HI7V=W>@?89:<ABCDEGJKLMbcNOPQR$%&FijghYZ[efk$%&'()*+,-./0NoneQV~x+Defines how to print out a function symbol.zRenders a function application. Takes the following arguments in this order: Pretty-printing level, current precedence, pretty-printed function symbol and list of arguments to the function.{9A class for customising the printing of function symbols.|.The style of the function symbol. Defaults to .}Print a value to the console.~4The empty document. Used to avoid name clashes with S.Print a tuple of values.Print a set of vlaues.7Generate a list of candidate names for pretty-printing.For operators like $) that should be printed as a blank space.-For functions that should be printed curried./For functions that should be printed uncurried.HA helper function that deals with under- and oversaturated applications.;A helper function that drops a certain number of arguments.For prefix operators.For postfix operators.For infix operators. For tuples._!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghxyz{|}~!}~{|xyzxyz{|NoneDNone "#0<FTVA queued critical pair. The score of this critical pair.@The rule which does the outermost rewrite in this critical pair.@The rule which does the innermost rewrite in this critical pair.!The position of the overlap. See .A critical pair queue.=A datatype representing all the type parameters of the queue.@The score assigned to critical pairs. Smaller scores are better.*The type of ID numbers used to name rules.A  packed for storage into a i. Must be an instance of j.An  packed for storage into a i. Must be an instance of j.Pack a . Unpack a .Pack an . Unpack a .The empty queue. Add a set of s to the queue.Remove the minimum  from the queue.Map a function over all s.klmnopqNone"#<7Describes whether an inequality is strict or nonstrict.0The first term is strictly less than the second.3The first term is less than or equal to the second.Return rN if the first term is less than or equal to the second, in the term ordering.Check if the first term is less than or equal to the second in the given model, and decide whether the inequality is strict or nonstrict.Return rO if the first argument is strictly less than the second, in the term ordering.YReturn the direction in which the terms are oriented according to the term ordering, or ) if they cannot be oriented. A result of s t) means that the first term is less than  or equal to the second.26None"#+37;<=>?FKST$ ^A function symbol extended with a minimal constant and Skolem functions. Comes equipped with  and  instances. The minimal constant. A Skolem function. An ordinary function symbol. &A hack for encoding Horn clauses. See !. The default implementation of  should work OK.kThe collection of constraints which the type of function symbols must satisfy in order to be used by twee.&For types which have a notion of size.Compute the size.'For types which have a notion of arity.Measure the arity.!Construction of Skolem constants.'Turn a variable into a Skolem constant. An instance  a b indicates that a value of type a contains a value of type b- which is somehow part of the meaning of the a.A number of functions use O constraints to work in a more general setting. For example, the functions in 4 operate on rewrite rules, but actually accept any a satisfying  a (  f).Use taste when definining $ instances; don't do it willy-nilly.Get at the thing.3The underlying type of function symbols of a given "."A builder compatible with a given ".0A triangle substitution compatible with a given ".'A substitution compatible with a given ". #A termlist compatible with a given ".!A term compatible with a given "."gGeneralisation of term functionality to things that contain terms (e.g., rewrite rules and equations).$ Compute a u` of all terms which appear in the argument (used for e.g. computing free variables). See also *.%&Apply a substitution. When using the " type class, you can use ) instead.&2Represents a unique identifier (e.g., for a rule).)Apply a substitution.*(Find all terms occuring in the argument.+-Find the variables occurring in the argument.,Test if the argument is ground.-4Find the function symbols occurring in the argument..>Count how many times a function symbol occurs in the argument./7Count how many times a variable occurs in the argument.0qRename the argument so that variables are introduced in a canonical order (starting with V0, then V1 and so on).1_Rename the second argument so that it does not mention any variable which occurs in the first.2(Check if a term is the minimal constant.3%Build the minimal constant as a term.4\Erase a given set of variables from the argument, replacing them with the minimal constant.!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh !"#$%&'()*+,-./0123456789:<=>?@ABCDEFHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkxyz{|}~      !"#$%&'()*+,-./012346"#$%)*! +,-./01&'(324          "#$%&'( NoneV.Check if one term is less than another in KBO.W8Check if one term is less than another in a given model.VWVW None"#< XA term index: a multimap from  f to a.YAn empty index.ZIs the index empty?[An index with one entry.\Insert an entry into the index.]Delete an entry from the index.^Look up a term in the index. Finds all key-value such that the search term is an instance of the key, and returns an instance of the the value which makes the search term exactly equal to the key._"Look up a term in the index. Like ^, but returns the exact value that was inserted into the index, not an instance. Also returns a substitution which when applied to the value gives you the matching instance.`GLook up a term in the index, possibly returning spurious extra results.a!Return all elements of the index. XYZ[\]^_`a XYZ[\]^_`avwxyz{|}~X NoneFTieOrder an equation roughly left-to-right. However, there is no guarantee that the result is oriented.j.Apply a function to both sides of an equation.k!Is an equation of the form t = t? defhgijkl efghdonmijklefgh None"#FTV#z6A proof, with all axioms and lemmas explicitly listed.|The used axioms.}The used lemmas.~The goals proved.Options for proof presentation.Never inline lemmas.Inline all lemmas.!Print out explicit substitutions.HThe number of the axiom. Has no semantic meaning; for convenience only.KA description of the axiom. Has no semantic meaning; for convenience only.%The equation which the axiom asserts. A lemma, which includes a proof.KThe id number of the lemma. Has no semantic meaning; for convenience only.A proof of the lemma.WA derivation is an unchecked proof. It might be wrong! The way to check it is to call  to turn it into a .:Apply an existing rule (with proof!) to the root of a term$Apply an axiom to the root of a term Reflexivity.  t proves t = t.Symmetry TransivititylCongruence. Parallel, i.e., takes a function symbol and one derivation for each argument of that function.-A checked proof. If you have a value of type Proof f0, it should jolly well represent a valid proof!The only way to construct a Proof f is by using . Checks a - and, if it is correct, returns a certified .If the # is incorrect, throws an exception.Simplify a derivation.@After simplification, a derivation has the following properties: is pushed down next to  and  only occurs inside  or at the top level* is right-associated and is pushed inside  if possible/Find all lemmas which are used in a derivation.VFind all lemmas which are used in a derivation, together with the substitutions used./Find all axioms which are used in a derivation.VFind all axioms which are used in a derivation, together with the substitutions used.4Applies a derivation at a particular path in a term.The default configuration. Construct a  ProvedGoal.5Check that pg_goal/pg_witness match up with pg_proof.Simplify and present a proof.Print a presented proof.Format an equation nicely.$Used both here and in the main file.6stuvwxyz{|}~8z{|}~stuvwxystuvwxyz{|}~ None"#<>?FKTVH+6A rewrite proof with the final term attached. Has an Ord( instance which compares the final term.A multi-step rewrite proof t ->* u1Apply a single rewrite rule to the root of a term Reflexivity Transivitity Congruence9A strategy gives a set of possible reductions for a term.A rule's orientation. and % rules are used only left-to-right.  and  rules are used bidirectionally.An oriented rule.A weakly oriented rule. The first argument is the minimal constant, the second argument is a list of terms which are weakly oriented in the rule.A rule with orientation  k ts" can be used unless all terms in ts are equal to k.A permutative rule.A rule with orientation  ts can be used if  map fst ts# is lexicographically greater than  map snd ts.An unoriented rule.A rewrite rule.7Information about whether and how the rule is oriented.The left-hand side of the rule. The right-hand side of the rule.&Is a rule oriented or weakly oriented?Is a rule weakly oriented?Turn a rule into an equation.zTurn an equation t :=: u into a rule t -> u by computing the orientation info (e.g. oriented, permutative or unoriented).NCrashes if t -> u is not a valid rule, for example if there is a variable in u which is not in t+. To prevent this happening, combine with .6Flip an unoriented rule so that it goes right-to-left.:Compute the normal form of a term wrt only oriented rules."Check if a term can be simplified.2Find a simplification step that applies to a term.4A smart constructor for Trans which simplifies Refl.3A smart constructor for Cong which simplifies Refl.6The list of all rewrite rules used in a rewrite proof.Turn a reduction into a proof.Construct a basic rewrite step. Construct a  from a .+Normalise a term wrt a particular strategy.ECompute all normal forms of a set of terms wrt a particular strategy.@Compute all successors of a set of terms (a successor of a term t is a term u such that t ->* u).$Apply a strategy anywhere in a term.4Apply a strategy to some child of the root function.kApply a strategy in parallel in as many places as possible. Takes only the first rewrite of each strategy.)A strategy which rewrites using an index.'A strategy which applies one rule only.>Check if a rule can be applied, given an ordering <= on terms.(Check if a rule can be applied normally./Check if a rule can be applied and is oriented.5Check if a rule can be applied in a particular model.CCheck if a rule can be applied to the Skolemised version of a term.3?None"#<VK& ^_` `_^None"#<>?FKTV`G BA critical pair together with information about how it was derived The critical pair itself. The depth of the critical pair. JThe critical term, if there is one. (Axioms do not have a critical term.)2A derivation of the critical pair from the axioms.<The configuration for the critical pair weighting heuristic.(Represents the depth of a critical pair.,A critical overlap of one rule with another.IThe depth (1 for CPs of axioms, 2 for CPs whose rules have depth 1, etc.)The critical term.<The part of the critical term which the inner rule rewrites. 5The position in the critical term which is rewritten.!The critical pair itself.#@The set of positions at which a term can have critical overlaps.&*Calculate the set of positions for a term.(3Compute all overlaps of a rule with a set of rules.+TCreate an overlap at a particular position in a term. Doesn't simplify the overlap.,2Simplify an overlap and remove it if it's trivial./$The default heuristic configuration.0$Compute a score for a critical pair.1:Split a critical pair so that it can be turned into rules.nThe resulting critical pairs have the property that no variable appears on the right that is not on the left.23Make a critical pair from two rules and an overlap.3#Return a proof for a critical pair.+     ! "#%$&'()*+,-./0123.#$%"4&' !()*+,-./0     65123      !#$%None"#<FTb?@CBADEFGHIJKLMNOP?@ABCDEGHIFJKLMNOP?@ABCNone"#&'>?FKTVpoMA message which is produced by the prover when something interesting happens.p A new rule.qA new joinable equation.rA rule was deleted.sThe CP queue was simplified.t&The rules were reduced wrt each other.uThe prover state.The prover configuration.!The default prover configuration.:Does this configuration run the prover in a complete mode?The initial state.Emit a message."Forget about all emitted messages.Get all emitted messages.'Compute all critical pairs from a rule.ATurn a Passive back into an overlap. Doesn't try to simplify it.Renormalise a queued Passive.Renormalise the entire queue. Enqueue a set of critical pairs.Dequeue a critical pair.Also takes care of:/removing any orphans from the head of the queueignoring CPs that are too big^QRSTUZYXWV[\]^dcba_`efmlkjihgnotsrqpuv~}|{zyxwkuvwxyz{|}~opqrstnefghijklm]^_`abcd[\TUVWXYZQRSQRSTUVWXYZ[\]^_`abcdefghijklmopqrstu vwxyz{|}~  !"#$%&'()*+,-./012345.6789:;<=>?@ABCDDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~o      !"#$%&'()*+,-./0123456W789:;c<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_` a o b ? c q d e f g h i j k l m n o p q r s t u v w x x y z { | } ~ ~                                                                                                                                    oc       !"#$%&'()*+,-./01234567899:;;<=>?@AABBCDEFGHIIJKLMNOPQRSTUVWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~?o%"*-M34%      !"#$%$&$'$($)$*$*$+$,$-$.$/$0$1$23453467789:;<=>?<=@ABC D E F G H I J K L a  % M = R N%twee-lib-2.1.4-5jsRXzOxs0U5YwctHpAxj7 Twee.Pretty Twee.Label Twee.Task Twee.Term Twee.UtilsTwee.PassiveQueueTwee.Constraints Twee.BaseTwee.KBO Twee.Index Twee.Equation Twee.Proof Twee.RuleTwee.Rule.IndexTwee.CP Twee.JoinTweeData.ChurchListData.DynamicArray Data.HeapTwee.Term.Coreunpack overlap_posScoreCPRulesplitpretty-1.1.3.3Text.PrettyPrint.HughesPJClass pPrintListpPrint pPrintPrecPrettyLabellabelNum unsafeMkLabellabelfind $fEqLabel $fOrdLabel $fShowLabelTasknewTask checkTaskBuilderVarVvar_idFunfun_idTermTermListApp UnsafeConsSymConsSym UnsafeConsConsEmptyatlenListfun fun_value singletonisSubtermOfList TriangleSubstTriangle unTriangleSubstunSubst SubstitutionSubstFun evalSubst substListBuildBuildFunbuilderFbuild buildListconappvar substToList foldSubstallSubst substDomainsubst substSize lookupList extendListretractunsafeExtendList substComposesubstCompatible substUnion idempotent idempotentOnclose canonicalise emptySubst listToSubstmatchmatchIn matchList matchListInunify unifyListunifyTri unifyListTriunifyListTriFromemptychildrenlookupextendlenbound boundList boundListsoccurs subtermsListsubtermsproperSubtermsisAppisVar isInstanceOf isVariantOf isSubtermOfmapFun mapFunListreplacePositionreplacePositionSubpositionToPathpathToPosition<<$fShowTermList $fShowTerm $fBuild[]$fBuildTermList $fBuildTerm$fBuildBuilder$fSubstitution(->) $fShowSubst$fSubstitutionSubst$fSubstitutionTriangleSubst $fEqSubst$fShowTriangleSubst TermStyle pPrintTerm PrettyTerm termStyle prettyPrint pPrintEmpty pPrintTuple pPrintSetsupply invisiblecurried uncurried fixedArityimplicitArgumentsprefixpostfix infixStyle tupleStyle $fPrettyFun $fPrettyRatio $fPrettyMap $fPrettyVar $fPrettySet $fPrettyDoc $fPrettySubst$fPrettyTermList $fPrettyTerm$fPrettyTermFunMingetMinMaxgetMaxrepeatM partitionBycollateisSorted isSortedByusortusortBysortBy'usortBy'orElse unbuffered getMaxWith getMinWithlabelMfixpointintMinintMax splitInterval $fMonoidMax $fMonoidMinPassive passive_score passive_rule1 passive_rule2 passive_posQueueParamsId PackedScorePackedId packScore unpackScorepackIdunpackIdinsert removeMinmapMaybe $fOrdPassive $fEqPassive$fOrdPassiveSet$fEqPassiveSet StrictnessStrict NonstrictOrderedlessEqlessInMinimalminimalModelBranchfunslessequalsFormulaLessLessEqAndOrAtomConstantVariableatomstoTermfromTerm negateFormulaconjdisj&&&|||truefalse trueBranchnorm contradictoryformAndbranchesaddLess addEqualsaddTermmodelToLiteralsmodelFromOrder weakenModel varInModel varGroups lessEqInModelsolvelessThan orientTerms $fPrettyAtom$fPrettyFormula$fPrettyBranch $fPrettyModel $fShowAtom$fEqAtom $fOrdAtom $fEqFormula $fOrdFormula $fShowFormula $fEqBranch $fOrdBranch $fEqModel $fShowModel$fEqStrictness$fShowStrictnessExtendedSkolemFunction EqualsBonushasEqualsBonusisEqualsisTrueisFalseSizedsizeArityarityskolem getSkolemHastheFunOf BuilderOfTriangleSubstOfSubstOf TermListOfTermOfSymbolic ConstantOftermsDLsubst_unIdtermsvarsisGroundoccoccVarrenameAvoiding isMinimal minimalTermerase $fPrettyId$fSymbolicMaybe $fSymbolic[]$fSymbolic(,,) $fSymbolic(,)$fSymbolicSubst$fSymbolicTermList$fSymbolicTerm$fHasaa $fArityFun $fSizedTerm$fSizedTermList $fSizedFun$fEqualsBonusFun$fEqualsBonusExtended$fSkolemExtended$fMinimalExtended$fArityExtended$fSizedExtended$fPrettyTermExtended$fPrettyExtended$fEqId$fOrdId$fShowId$fEnumId $fBoundedId$fNumId$fRealId $fIntegralId $fEqExtended $fOrdExtended$fShowExtended$fFunctorExtendedIndexnulldeletematches approxMatcheselems$fDefaultIndex $fShowIndex EquationOfEquation:=:eqn_lhseqn_rhsorder bothSidestrivial simplerThan$fSizedEquation$fPrettyEquation$fSymbolicEquation $fEqEquation $fOrdEquation$fShowEquation ProvedGoal pg_numberpg_namepg_proof pg_goal_hintpg_witness_hint Presentation pres_axioms pres_lemmas pres_goalsConfigcfg_all_lemmas cfg_no_lemmascfg_show_instancesAxiom axiom_number axiom_name axiom_eqnLemmalemma_id lemma_proof DerivationUseLemmaUseAxiomReflSymmTransCongProofequation derivationcertifysimplifylemmaaxiomsymmtranscong usedLemmasusedLemmasAndSubsts usedAxiomsusedAxiomsAndSubstscongPath defaultConfig provedGoalcheckProvedGoalpresentpPrintPresentationdescribeEquation $fPrettyAxiom $fPrettyLemma$fPrettyDerivation $fPrettyProof$fSymbolicDerivation $fOrdLemma $fEqLemma$fPrettyPresentation $fEqAxiom $fOrdAxiom $fShowAxiom$fEqDerivation$fShowDerivation $fShowLemma $fEqProof $fShowProof$fShowProvedGoal$fShowPresentation Resultingresult reduction ReductionStepStrategy OrientationOrientedWeaklyOriented Permutative UnorientedRuleOf orientationlhsrhsorientedweaklyOrientedunorientorient backwards simplify1 canSimplifycanSimplifyList simpleRewritestepsreductionProofstepreduce normaliseWith normalForms successorssuccessorsAndNormalFormsanywherenestedparallelrewritetryRule reducesWithreducesreducesOrientedreducesInModel reducesSkolem$fSymbolicOrientation$fOrdOrientation$fEqOrientation $fPrettyRule $fHasRuleTerm$fSymbolicRule$fPrettyReduction$fSymbolicReduction$fPrettyResulting$fSymbolicResulting$fOrdResulting $fEqResulting$fShowOrientation$fEqRule $fOrdRule $fShowRule$fShowReduction$fShowResulting RuleIndexindex_oriented index_weak index_all$fShowRuleIndex CriticalPaircp_eqncp_depthcp_topcp_proof cfg_lhsweight cfg_rhsweight cfg_funweight cfg_varweightcfg_depthweight cfg_dupcost cfg_dupfactorDepth OverlapOfOverlap overlap_depth overlap_top overlap_inner overlap_eqn PositionsOf PositionsNilPConsP positionspositionsChurchoverlapsoverlapsChurchasymmetricOverlaps overlapAtsimplifyOverlapbuildReplacePositionSub termSubstscoremakeCriticalPair overlapProof$fShowPositions$fPrettyCriticalPair$fSymbolicCriticalPair $fEqDepth $fOrdDepth $fNumDepth $fRealDepth $fEnumDepth$fIntegralDepth $fShowDepth $fShowOverlapcfg_ground_joincfg_use_connectedness cfg_set_joinjoinCriticalPairallStepsstep1step2step3joinWithsubsumed groundJoingroundJoinFromgroundJoinFromMaybevalidoptimiseOutputoutput_messageGoal goal_name goal_numbergoal_eqngoal_lhsgoal_rhsRuleId ActiveRule rule_activerule_rid rule_depth rule_rule rule_proofrule_positionsActive active_id active_depth active_rule active_top active_proof active_model active_rulesMessage NewActive NewEquation DeleteActive SimplifyQueue InterreduceStatest_rules st_active_ids st_rule_ids st_joinablest_goalsst_queuest_next_active st_next_rule st_consideredst_messages_revcfg_accept_termcfg_max_critical_pairscfg_max_cp_depth cfg_simplifycfg_renormalise_percentcfg_critical_pairscfg_joincfg_proof_presentationconfigIsComplete initialStatemessage clearMessagesmessages makePassives findPassivesimplifyPassive simplifyQueueenqueuedequeue active_cp addActive addActiveOnly deleteActiveconsider considerUsingaddCPaddAxiom addJoinableaddGoalnormaliseGoalsrecomputeGoalsgoal interreduce interreduce1complete complete1solved solutionsrules completePure normaliseTerm simplifyTerm$fParamsParams$fHasActiveRulePositions$fHasActiveRuleLemma$fHasActiveRuleProof$fHasActiveRuleRule$fHasActiveRuleDepth$fHasActiveRuleRuleId$fHasActiveRuleId$fEqActiveRule$fSymbolicActiveRule$fPrettyActive $fEqActive$fPrettyMessage $fEqRuleId $fOrdRuleId $fShowRuleId $fNumRuleId $fRealRuleId$fIntegralRuleId $fEnumRuleId ChurchListfoldretanilunitconsappendjoinfromListtoListfoldl'filter fromMaybeArray arraySize arrayContentsDefaultdefnewArray!updateHeapunionbaseGHC.BaseNothingHeap1NilNodeCaches caches_nextId caches_from caches_toTaskData task_start task_last task_spenttask_frequency task_budget task_whatmemptymappend occursListBuilder1 unBuildertermlistroothighlowarraySymbolisFunindextoSymbol fromSymbol unsafePatHeadpatHeadpatTerm eqTermList weqTermListcompareContents buildTermList getByteArraygetSizegetIndexputIndexliftSTbuiltthen_checkedemitSymbolBuilderemitAppemitVar emitTermList isSubArrayOfsymbolOccursList prettyParen prettyShow prettyNormal PrettyLevelText.PrettyPrint.HughesPJ fullRender renderStylerenderfirstfsepfcatcatsep<+><>$+$$$ punctuatehangnestvcathsephcat reduceDocmaybeDoubleQuotes maybeQuotes maybeBraces maybeBrackets maybeParensbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenspacecoloncommasemiisEmpty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstyle TextDetailsChrStrPStrStylemode lineLengthribbonsPerLineModePageMode ZigZagModeLeftMode OneLineMode&vector-0.12.0.1-LflPw1fguMb6as60UrZpxNData.Vector.Unboxed.BaseVectorUnbox PassiveSetpassiveset_bestpassiveset_rulepassiveset_leftpassiveset_rightghc-prim GHC.TypesTrueJustLT$dlist-0.8.0.4-C5jxmU4NyxKI1pN7pAcXnu Data.DListDListStackFrameYieldStop frame_term frame_index frame_rest yield_found yield_resthere