uN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"                  r !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~r &%$#"!!"#$%&'(()**+,3210/.--./0123455677899:>=<;;<=>?@@APONMLKJIHGFEDCBBCDEFGHIJKLMNOPQUTSRRSTUVWWX edcba`_^]\[ZYYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    NRN   For conversion                !"#$% !"#$% $#"!  !"#$% &'()*+,-./01&'()*+2,-3./01 &'()*+,-./01456789:;<=>?@ABCDEFGHI 89:;=BCDEI 89:;=BCDEIJJJ-KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw1KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnxopqyzrstuvw{-KLMRQPONNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw|}|}|}~~~"&"     !     !     !      !"#$%&'( )!"*+,-#$%.&'(   !"#$%&'( non-portable experimentaleb@dcs.st-and.ac.ukJ-Haskell types which can be used as constants source file, line number additional annotations Staging annotation Staging annotation Staging annotation Staging annotation  !"#$%&'()*+,-./0ECategories for names; typechecked terms will know what each variable  is for. 1 Use for sending to typechecker. 2345673Abstract type representing a TT term and its type. 89:;)Construct a term representing a variable Variable name <7Make an application of a function to several arguments =2Get a pattern matchable representation of a term. >0Get a pattern matchable representation of a term's type. /?1Return whether the name occurs free in the term. @*Return the names occurring free in a term A9Return whether a subterm occurs in a (first order) term. BEGet the function from an application. If no application, returns the  entire term. C/Get the arguments from a function application. D6Get the argument names and types from a function type E)Get the return type from a function type 0AMatch the second argument against the first, returning a list of I the names in the first paired with their matches in the second. Returns K Nothing if there is a match failure. There is no searching under binders. 1G0Substitute a name n with a value v in a term f H.Transform a term according to a rewrite rule. #Left hand side, with metavariables $Right hand side, with metavariables Term to rewrite I  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHS9:0654321;78 -*'&$  ./+,/()/()/(%)!"#!"/ <=> ?@AGBCHDEFG  --*'&$  ./+,/()/()/(%)!"#!"/  !"#$%&'()*+,-./06543211234567889:;<=>?@ABCDEGH non-portable experimentaleb@dcs.st-and.ac.uk 2345I+Basic parsec combinator for parsing terms.  Extra parse rules (for example = for any primitive types or operators you might have added). J+Parse a term which is not an application; ! use for parsing lists of terms. 671Parse an expression with infix expressions (doesn' t work!) K9Basic parsec combinator for parsing inductive data types  Extra parse rules (for example = for any primitive types or operators you might have added). 89LBParse a string into a ViewTerm, without mucking about with parsec  or any extra parse rules. MDParse a string into an Inductive, without mucking about with parsec  or any extra parse rules. IJKLMIJKLMIJKLM:;<=>?@ABCDEFGHIJKLMNOP:;<=>?@ABCDEFGHIJKLMNOP:;;<==>A@??@AB MLKJIHGFEDCCDEFGHIJKLMNOPQQQ non-portable experimentaleb@dcs.st-and.ac.ukRSTUVWN.Environment and goal type for a given subgoal XOGet the premises of the goal PGet the name of the goal QGet the type of the goal RTypes of elimination rule STUV[Allow metavariables in the definition, which will become theorems which need to be proved. WNo termination checking XNo need to cover all cases YZ[\]^_`abcdefghijklmnoYpqTypecheck a term ZrDA tactic is any function which manipulates a term at the given goal - binding. Tactics may fail, hence the monad. s2Abstract type representing goal or subgoal names. [\t0Abstract type representing state of the system. ]uvw9Initialise a context, with no data or definitions and an  empty proof state. x^yzQuickly convert a   into a real 87. B This is dangerous; you must know that typechecking will succeed,  and the resulting term won'%t have a valid type, but you will be H able to run it. This is useful if you simply want to do a substitution  into a  . _FConvert a term to matchable pattern form; i.e. the only names allowed G are variables and constructors. Any arbitrary function application is  removed. {|*Add a new definition to the global state. I By default, these definitions must cover all cases and be well-founded, 5 but can be optionally partial or general recursive. G Returns the new context, and a list of names which need to be defined  to complete the definition. Type  Definition 2Options to set which definitions will be accepted }9Add a new definition, with its type to the global state. 7 These definitions can be recursive, so use with care. ~*Add a new definition to the global state. `3Forget a definition and all following definitions. DAdd the general recursion elimination rule, thus making all further  definitions untrustworthy :). Name to give recursion rule Add the heterogenous (" John Major"") equality rule and its reduction Name to give equality type Name to give constructor ,Declare a name which is to be defined later 8Declare a type constructor which is to be defined later %Add a new axiom to the global state. AAdd a new primitive type. This should be done in assocation with  creating an instance of ( for the type, and creating appropriate  primitive functions.  Type name CAdd a new binary operator on constants. Warning: The type you give  is not checked! CAdd a new binary function on constants. Warning: The type you give  is not checked! GAdd a new primitive function on constants, usually used for converting ? to some form which can be examined in the type theory itself. , Warning: The type you give is not checked! 'Add a new externally defined function. , Warning: The type you give is not checked! arity The function, which must 3 accept a list of the right length given by arity. AAdd implicit binders for names used in a type, but not declared. ? |Returns the new type and the number of implicit names bound. Begin a new proof. $Begin a new interactive definition.  Actually, just the same as  but this version allows you to A make recursive calls, which should of course be done with care. ?Suspend the current proof. Clears the current proof state; use   to continue the proof. EResume an unfinished proof, suspending the current one if necessary. = Fails if there is no such name. Can also be used to begin a 8 proof of an identifier previously claimed as an axiom.  Remember that you will need to ! the goal if you are resuming an  axiom. 8Freeze a name (i.e., set it so that it does not reduce) # Fails if the name does not exist. ,Unfreeze a name (i.e., allow it to reduce). # Fails if the name does not exist. Save the state (e.g. for Undo) FClears the saved state (e.g. if undo no longer makes sense, like when  a proof has been completed) 6Restore a saved state; fails if none have been saved. a4Normalise a term and its type (using old evaluator_ 4Reduce a term and its type to Weak Head Normal Form @Reduce a term and its type to Normal Form (using new evaluator) DReduce a term and its type to Normal Form (using new evaluator, not  reducing given names) IReduce a term and its type to Normal Form (using new evaluator, reducing ( given names a maximum number of times) .Check a term in the context of the given goal 1Evaluate a term in the context of the given goal FCheck whether the conversion relation holds between two terms, in the  context of the given goal $Lookup a definition in the context. -Get the type of a definition in the context.  Check whether a name is defined GReturn the data type with the given name. Note that this knows nothing G about the difference between parameters and indices; that information 9 is discarded after the elimination rule is constructed. @Lookup a pattern matching definition in the context. Return the " type and the pattern definition. +Get all the names and types in the context 9Get all the pattern matching definitions in the context. / Also returns CAFs (i.e. 0 argument functions) TIs the name an auxiliary function of a pattern definition (e.g. generated by a with  clause? 7Get all the inductive type definitions in the context. @Get the names of all of the constructors of an inductive family 1Find out what type of variable the given name is AGet an integer tag for a constructor. Each constructor has a tag A unique within the data type, which could be used by a compiler. (Get the arity of the given constructor. 5Get the pattern matching elimination rule for a type Type .Which rule to get patterns for (case or elim) b"Get the goals still to be solved. +Return whether all goals have been solved. !Get the number of unsolved goals :Return whether we are in the middle of proving something. @Get the current proof term, if we are in the middle of a proof. 9Get the type and context of the given goal, if it exists !Get information about a subgoal. Get all bindings (True), or  just lambda bindings (False) %Get the names and types of all goals (Create a name unique in the proof state Suggested name $Unique name based on suggested name 'Lift a finished proof into the context c6Focus on a different hole, i.e. set the default goal. Hide a premise #The Identity tactic, does nothing. +The Tracing tactic; does nothing, but uses d to dump the  current proof state eHSequence two tactics; applies two tactics sequentially to the same goal f>Apply a tactic, then apply another to each subgoal generated. g?Apply a sequence of tactics to the default goal. Read the type  as [r] -> r HApply a tactic, then apply the next tactic to the next default subgoal. Try a tactic. Tactic to apply Apply if first tactic succeeds Apply if first tactic fails. FTries the left tactic, if that fails try the right one. Shorthand for   x  y. h!Prepare a goal for introduction. Name for new goal !Prepare a goal for introduction. Make a local claim %Solve a goal by applying a function. F If the term given has arguments, attempts to fill in these arguments & by unification and solves them (with ).  See  and  for slight variations. %Solve a goal by applying a function. G If the term given has arguments, this will create a subgoal for each. F Some arguments may be solved by unification, in which case they will H already have a guess attached after refinement, but the guess will not  be solved (via ). CSolve a goal by applying a function with some arguments filled in.  See  for details. Finalise a goal' s solution. ?If the goal has a solution, finalise it, otherwise prepare the  goal (with attack). I Typically, could be used on the subgoals generated by refinement, where F some may have solutions attached already, and others will need to be  prepared. 9Finalise as many solutions of as many goals as possible. Attach a solution to a goal. Remove a solution from a goal. iCRemove all claims with no guesses attached and which are unused in  their scope. j-Substitute a let bound value into its scope. .Rename the outermost binder in the given goal 0Introduce an assumption (i.e. a lambda binding) 0Introduce an assumption (i.e. a lambda binding) Name for the assumption #Keep introducing things until there's nothing left to introduce. #Keep introducing things until there's nothing left to introduce, $ Must introduce at least one thing. As ", but with names, and stop when we've run out of names. $ Fails if too many names are given. ?Check that the goal is definitionally equal to the given term, # and rewrite the goal accordingly. *Abstract over the given term in the goal. AAbstract over the given term in the goal, and also all variables 1 appearing in the goal whose types depend on it. EAdd a new top level argument after the arguments its type depends on I (changing the type of the theorem). This can be useful if, for example, 5 you find you need an extra premise to prove a goal. AReplace a term in the goal according to an equality premise. Any B equality type with three arguments is acceptable (i.e. the type,  and the two values), > provided there are suitable replacement and symmetry lemmas. ' Heterogeneous equality as provided by  is acceptable  (if you provide the lemmas!). Equality type (e.g. Eq : (A:*)(a:A)(b:A)*) replacement lemma (e.g. 8repl : (A:*)(a:A)(b:A)(q:Eq _ a b)(P:(a:A)*)(p:P a)(P b)) symmetry lemma (e.g. +sym : (A:*)(a:A)(b:A)(p:Eq _ a b)(Eq _ b a)) equality premise .apply premise backwards (i.e. apply symmetry) ?Add an axiom to the global context which would solve the goal,  and apply it.  FIXME: This tactic doesn',t pick up all dependencies on types, but is 7 okay for simply typed axioms, e.g. equations on Nats. Name to give axiom Premises to pass to axiom Normalise the goal Beta reduce in the goal 3Beta reduce the goal, unfolding the given function +Prepare to return a value in a computation !Prepare to return a quoted value Apply an eliminator. )An elimination rule applied to a target. 2Apply the appropriate induction rule to the term. target of the elimination 6Apply the appropriate case analysis rule to the term.  Like ), but no induction hypotheses generated. target of the case analysis EFind a trivial solution to the goal by searching through the context 9 for a premise which solves it immediately by refinement k<Make a recursive call of a computation. The term must be an ? allowed recursive call, identified in the context by having a  labelled type. DCreate a .hs file containing (unreadable) Haskell code implementing  all of the definitions. 4 (TODO: Generate a more readable, usable interface) context to compile root of filenames to generate   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~wtzpqmnoelkjihgfxyd~}[`\abc]a^_YZUXWV|{RTSsuvrNOPQOPQNOPQOPQRTSSTUXWVVWXYZZ[ `\abc]a^_\]^_`abcdelkjihgffghijklmnonopqqrstuvwxyz{|}~  non-portable experimentaleb@dcs.st-and.ac.uk lmnop"Get reply from last shell command qrstu lmnopqrstu lmnopqrstulmnopqrstu!wvwxyz{|}~Ivwxyz{|}~Ivxwwxy"~}|{zz{|}~! non-portable experimentaleb@dcs.st-and.ac.ukDTries to solve a simple goal automatically by trying each of these  in turn:  * Looking for an assumption ()  *  everything then solve by  5 * Splitting the goal, then solving each subgoal by  A * If the goal is of a type with more than one constructor, try  ! on each constructor in turn. * FIXME: not that this actually works yet.  Search depth CSplit a goal into subgoals. Type of goal must be a one constructor  family, with constructor c, then proceeds by  c. CSplit a goal into subgoals. Type of goal must be a two constructor  family, with constructors l and r, then proceeds by  l. CSplit a goal into subgoals. Type of goal must be a two constructor  family, with constructors l and r, then proceeds by  r. 2Solve the goal by applying a numbered constructor BEnsure at least this number of constructors (0 for no constraint) 4Use this constructor (0 based, order of definition) -Solve an existential by providing a witness. 5 More generally; apply the first constructor of the  goal'Es type and provide the witness as its first non-inferrable argument.  Witness Try to solve a goal A by evaluating a term of type Maybe A . If the  answer is Just a', fill in the goal with the proof term a. " non-portable experimentaleb@dcs.st-and.ac.uk non-portable experimentaleb@dcs.st-and.ac.uk 8Add primitive types for Int, Float and String, and some ' primitive operations [add,sub,mult,div] [int,float] and concat. Parse a primitive constant "Parse a term including primitives portable experimentaleb@dcs.st-and.ac.ukCLoad the given plugin file (which should be a full path to a .o or C .hs file) and update the Context. If it is a .hs file, it will be  compiled if necessary. ! Plugins must contain the symbol  1plugin_context :: Monad m => Context -> m Context > which updates the context. It may optionally contain symbols   plugin_parser :: Parser ViewTerm  which adds new parsing rules,  +plugin_shell :: ShellState -> IO ShellState  which updates the shell  Jplugin_commands :: IO [(String, String -> COntext -> IO (String, Context))] f which adds new user defined commands (which may need to do some setting up themselves, hence the IO) K Returns the new context and the extra parsing rules and commands, if any.  non-portable experimentaleb@dcs.st-and.ac.ukCreate a new shell state. Initial system state Update the context in a shell Function to update context (Add a user defined tactic to the shell.  Tactic name. pTactic function. The argument is whatever was input on the shell; the function is responsible for parsing this. "Shell to which to add the tactic. )Add a user defined command to the shell. Command name. Command function. The argument is whatever was input on the shell; the function is responsible for parsing this. The command returns a string (the response) and a possibly updated context. #Shell to which to add the command. ,Add another parsing rule for parsing terms. Parse a term using the shell's current parser extensions +Get the system state from a finished shell 7Get a string representation of the current proof state )Set up the equality type, for use by the  tactic Run a command shell. Prompt string Initial state #Send a command directly to a shell BSend a command directly to a shell, allowing commands which might  do IO actions. &Get the install prefix of the library DImport a file of shell commands; fails if the module does not exist J in the current directory or search path, does nothing if already loaded. *Add a directory to the module search path 8Add the standard library path to the module search path  #$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN#OPQRSTUVWXXYZ[\]^_`abcdefghijklmnopqrstuvwxyyz{|}~z             ! " # $ % & ' ( ) * + , - . / 0 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I < J K F L I M N O P = Q R 4 6 8 : S T U R < V > @ B W H L s 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 { | } g ~          e                                                                                       )         x                   :\      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~)pt      !"#$%&'()*+,-./0123456789:;<=>?n@ABCDEFGHIJKLMNOf_P Q R S T U V 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!{!|!}!~!!\!!!!!w!!!!!!!!!!!!!!!!!!!"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!R!!!!!!!!!!!!!!!!  ivor-0.1.11 Ivor.ViewTermIvor.TermParserIvor.TT Ivor.ShellIvor.ConstructionIvor.Primitives Ivor.Plugin Ivor.Prefix Ivor.Constant Ivor.Gadgets Ivor.TTCore Ivor.Errors Ivor.Values Ivor.NobbyIvor.Evaluator Ivor.Grouper Ivor.UnifyIvor.TypecheckIvor.Scopecheck Ivor.Tactics Ivor.DisplayIvor.PatternDefs Ivor.Datatype Ivor.MakeData Ivor.ICompileIvor.SC Ivor.Bytecode Ivor.CodegenC Ivor.State Ivor.RunTT Ivor.CompilerIvor.ShellStateIvor.ShellParser Ivor.EqualityName Inductivetypecon parametersindicescontype constructors ViewConsttypeofAnnotFileLocViewTermMetavar Annotation annotationterm PlaceholderEscape escapedtermEvalevaltermCodecodetypeQuote quotedtermStarConstantReturn returntermCallcalltermLabelfnamefargs labeltypeLetvarvalForallLambdavartypescopeAppfunargnametypevarNameTypeUnknownElimOpTypeConDataConFreeBoundTermname displayNamemkVarapplyviewviewTypefreeInnamesInoccursIngetApp getFnArgs getArgTypes getReturnTypedbgshowsubst transformpTermpNoApp pInductiveparseTermStringparseDataStringGoalDatabindingsgoalNamegoalTypeRuleElimCasePattOptHoleyGenRecPartialPatternsPClause PWithClauseeqproof scrutineepatterns arguments boundnames returnvalTTMTTError ErrContext CantInfer NoSuchVarUnboundMessageNotConvertible CantUnifyIsDataaddData addDataNoElimIsTermcheckTacticGoalContextgoal defaultGoal emptyContextttfailgetError fastCheck toPattern addPatternDef addTypedDefaddDef forgetDef addGenRec addEqualitydeclare declareDataaddAxiom addPrimitiveaddBinOpaddBinFn addPrimFn addExternalFn addImplicittheorem interactivesuspendresumefreezethawsave clearSavedrestoreevalwhnfevalnewevalnewWithout evalnewLimit checkCtxtevalCtxtconvertsgetDefgetTypedefined getInductive getPatternDef getAllTypesgetAllPatternDefs isAuxPatterngetAllInductives getAllDefsgetConstructorsnameTypegetConstructorTaggetConstructorArity getElimRulegetGoals allSolved numUnsolvedproving prooftermgetGoalgoalDatasubGoals uniqueNameqedfocushideidTactraceTac>->>=>tacs>+>try>|> attackWithattackclaimrefine basicRefine refineWithsolvetrySolve keepSolvingfillabandonrenameintro introNameintrosintros1 introsNamesequiv generalisedependentGeneraliseaddArgreplace axiomatisecomputebetaunfoldreturnComputationquoteValby inductioncasestrivialcallcompile ShellStateresponseautosplitleftrightuseConexistsisItJust addPrimitivesparsePrimitives parsePrimTermloadnewShell updateShell addTactic addCommand extendParsershellParseTerm getContextshowProofState configureEqrunShell sendCommand sendCommandIOprefix importFile addModulePath addStdlibPathSpineSnocEmptyResultFailureSuccessForgetforget traceIndex safeIndex??sizeloselistify revlistifylookupMfindFileunJustendstartPMFunPMDefPMRawSchemeSch RawSchemeRSchRawWithRWRetRWithMNUNPatternPMarkPTermPMarkConPConstPConPVarIndexedIndLevelledLevEnvBindMatchAnyGuessHolePiBinderBScopeSc constTypeStage ComputationCompTTConstProjMetaTyConConVPRStageREscapeREvalRCodeRQuote RComputationRCompRawRFileLocRAnnotRReturnRCallRLabelRMetaRInferRStarRConstRBindRAppVarsLiftsLiftfsLiftMvappindexiselevelisepappmakePs makePsUniquniqifyAllStatefinalisepure binderMap updateMetasgetNames getBoundNames substName substTerm mapSubTermgetArgs getRawArgsgetFun getExpecteduniqify mangleNamebindappArgspToV makePsEnvuniqifyAllStateBuniqifyAllStateCpurebindgetSctestidtesttermmkapp getargnames getappargs getappfun getrettype nameOccursoccCompoccBindoccStagefileLinedebugTTpToV2IvorMIErrorIContext ICantInfer INoSuchVarIUnboundIMessageINotConvertible ICantUnifycheckRealNamesifailNormalValueKripkeKr WeakeningWkMCompBlockedBEscapeBEvalBVBPBRecBPrimOpBPatDefBElimBTyConBConReadyRdInferRdQuoteRdCodeRdReturnRdCallRdLabelRdStarRdConstRTyConRConRdBindModelMBMREvPrimPrimOpElimRuleGammaGamGvalGPlicity FunOptionsTotal RecursiveFrozenElimsNoConstructorsYet elimRuleName caseRuleNameGlobal Undefined UnreducibleTConDCon PatternDefFun defplicitemptyGamgetAList lookupval lookuptypeglookup getTyNamerecCon insertGam concatGam setFrozensetRecremovegInsertgetglobgettype getplicityextendquotequote'WeakweakenweakenpPatValsCtxtVGnfdocallkrApplypatmatchpmpmatchsplicekrquotemakeApp normalise etaNormalise convNormalise normaliseEnvconvNormaliseEnvarity checkdupsSEnvStack eval_whnfeval_nfeval_nf_without eval_nf_limitevaluate eval_nfEnv tidyNamesGroupTTGCantGStarGConstGProjGPiGLetGLamGAppGElimGTyConGConGVGPgroupSubstUnifiedunifyunifyenvunifyenvCollect unifyenvErrunifynf unifyCollect unifynferrueq substNamesunifySubstTerm envToGamHACKsentinel FileContextFCLevel CheckStateconvert checkConv checkConvEnv typechecktypecheckAndBindtcClaimerrCtxt errCtxtCS doConversion convertAllEnv checkAndBindcheckAndBindWithcheckAndBindPairlvlcheck discharge checkNotHoleyverify scopeCheckHoleFn TacticActionHideGoalAddAxiomSolvedNextGoalAddGoalfindholeallholes holecheck runtactic runtacticEnvtacretthenTattempt makeholey claimholey claimsolved getClaims uniqifyClaimsdoClaimsregretcutevalGoal betaReduce reduceWithcasetac runCaseTac rename_usertidyuniqifyBinderssensibleintrostyptovenvdisplayHoleContext displayHolecheckDefcheckWellFounded matchClausesmkScheme checkCoverage expandClause validClausesmostSpecClausemoreSpecClause' expandConcombinemostSpecmoreSpec isConPattmatches getMatchesmatches'moreSpecClause showClausesDatatypeDatatycondatacons num_paramserulecrule e_ischemes c_ischemes e_rawschemes c_rawschemes RawDatatypeRDatartycon rdatacons rnum_paramsrerulercrule re_ischemes rc_ischemesDatadecl datatyconparams tycontype checkTypecheckTypeNoElim checkSchememkPat getPatVarsproject substVars dummyRulegetPatgetRedgetArity checkCons ConstructorsParams mkRawData mkSchemesmkCon mkDatacons mkCaseTypemkIArgsmkIRet bindParams bindIndices bindTarget bindMotive bindMethods applyMethodisrec placeholder SimpleCase ImpossibleIReducecompileSchemesmangleArgOrder numDisjointdoCase1mkElim allDisjointSCBody SSomeType SCantHappenSCaseSStarSConstSProjSPiSLetSAppSTyConSConSVSPSCSLamSCsSCNameSNNliftcollectelimSCshowSCsshowSCshowBodyshowBsByteDefFunInfoFIbytecodecnamectagfarityctagidByteOpCASEALETTAILCALLTYPEEVALTMPEVAL CLOSUREADDGETARGVARCLOSURECONCALLRETURNTMPDECLARESTARTFNBytecodeTmpVarTagAritymapInc compileAllscompileadddeclsgetTaggetCNamemkEval mkHeadersmkCode writeCodeIStateIStdefsdatadefs eliminators holequeuehidden proofstateactions namesupply undoStaterespondgensymdoDatadoMkData suspendProof resumeProof dumpState initstate jumpqueuestailprf saveState suspendFromvt matchMeta replaceMeta TokenParserlexerapparrowpNoInfixpExpbindList computationRunTTsRGamTypeInfoTIRTBinderRTLetRTPiRTLamRunTT RTCantHappenRTypeValRTConstRTProjRTCaseRTBindRTAppRTElimRTConRTFunRTVarRunValuemkRTFunmkRTElim RecAllowedRecflexiblefunctionargs hypothesisaddData'raw DefaultGoaltt mkRawClause checkBound uglyPrint getResponseqedLiftbase Debug.TracetraceseqTacthenTacnextTacrunTac allowedrecShellrepldatapromptfinishedcontext usertactics usercommandsimported extensions modulePathInputCommand RunTactic UserTacticDecideCases InductionByExists AutoSolveRightConLeftConSplitTrivialUnfold Normalise AxiomatiseReplace GeneraliseEquivAddArg IntrosNamesIntros IntroNameIntroRenameAbandonCallTacQuoteTac ReturnTacFillSolveRefineLocalClaim AttackWithAttack UserCommandDrop PrimitivesJMEqQedPrfStatePrfUndoDumpFocusCompilePluginLoadResumeSuspendThawFreezeReplDataCheckPrintWHNFEvalTerm InteractiveTheorem DeclareDataDeclareAxiomTypedDefDef readToEnddeftypeddefpclause pclauseret pclausewith ppatternspPattOpt ppatternDefpdataplataaxiompdeclareptheorempinterpforgetpwhnfpprintpdroppprimspqedpgenrecpjmepprf pprfstatepundopfreezepthawpfocuspdumppsuspendpresumeploadppluginpcompilepusertryallcommandtacticpossibleinput parseInputintToNat intToStringstringEqparseInt respondLn readToSemi runCommanddumpAllprocess processInputloopgettacs environmenttempfile