!wG      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%& ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~                                          !!"""#########################################################$$$$$$$$$$$%%%%%%%%%%%%%%%%&&&&&&&& & & & & &&&&&'''''((((((((( (!("(#($(%(&(')()))**+*,*-*.*/*0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@+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-[-\-].^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p0q0r0s0t0u0v1w2x2y3z3{3|4}4~4445555555555555555669NoneoGHIJGHIJSafepyliquid-fixpointExamples KLMNOPQRST NOKLMPQRST7SafeqSaferYliquid-fixpointAlso known as  in pretty&, but that clashes with Semigroup's <>C  !"#$%&'()*+,-./012345678<;:9A@?>=FEDCBYC  !"#$%&'()*+,-./012345678<;:9A@?>=FEDCBYY6None ,PUVXzjliquid-fixpoint:Unique Int -----------------------------------------------kliquid-fixpoint:Edit Distance --------------------------------------------liquid-fixpoint!If loud, write a string to stdoutliquid-fixpoint<let em = M.fromList [ (1, [2, 3]), (2, [1, 3]), (3, [] ) ]+let ef = \v -> (v, M.lookupDefault [] v em)sccsWith ef [1,2,3] [[3],[1,2]] [Z[\a`_]^bcdefghijklmnopqrstuvwxyz{|}~[bcdefghijk\a`_]^lmnopqrstuvwxyz{|}~[ZNoneXliquid-fixpoint!Constraint Generation Informationliquid-fixpoint&Input to constraint solving (fixpoint)liquid-fixpoint)Output from constraint solving (fixpoint)liquid-fixpoint(HTML file with inferred type annotationsliquid-fixpointText file with inferred typesliquid-fixpointVim annotation fileliquid-fixpointHaskell sourceliquid-fixpointHaskell sourceliquid-fixpointLiterate Haskell sourceliquid-fixpointJavaScript sourceliquid-fixpointTypescript sourceliquid-fixpoint%Spec file (e.g. include/Prelude.spec)liquid-fixpointDLifted-Spec file, containing automatically generated specifications liquid-fixpoint-Qualifiers file (e.g. include/Prelude.hquals)liquid-fixpointFinal result: SAFE/UNSAFEliquid-fixpointHTML file with templates?liquid-fixpoint8Markdown file (temporarily generated from .Lhs + annots)liquid-fixpoint-JSON file containing result (annots + errors)liquid-fixpoint*Previous source (for incremental checking)liquid-fixpoint*Previous output (for incremental checking)liquid-fixpointConstraint Graphliquid-fixpoint Partitionliquid-fixpoint0SMTLIB2 queries for automatically created proofsliquid-fixpoint$Binary representation of .fq / FInfoliquid-fixpointSMTLIB2 query fileliquid-fixpoint#filter constraints with delta debugliquid-fixpoint"filter qualifiers with delta debugliquid-fixpointfilter kvars with delta debugliquid-fixpoint7Hardwired Paths and Files -----------------------------++None27=?6!liquid-fixpointGEliminate describes the number of KVars to eliminate: None = use PA/Quals for ALL k-vars, i.e. no eliminate Some = use PA/Quals for CUT k-vars, i.e. eliminate non-cuts All = eliminate ALL k-vars, solve cut-vars to TRUE Horn = eliminate kvars using the Horn solver Existentials = eliminate kvars and existentialsliquid-fixpoint1src file (*.hs, *.ts, *.c, or even *.fq or *.bfq)liquid-fixpoint)number of cores used to solve constraintsliquid-fixpointMinimum size of a partitionliquid-fixpoint2Maximum size of a partition. Overrides minPartSizeliquid-fixpointwhich SMT solver to useliquid-fixpoint not interpret div and mul in SMTliquid-fixpoint&interpretation of string theory by SMTliquid-fixpointdefunctionalize (use apply$ for all uninterpreted applications)liquid-fixpoint3allow higher order binders in the logic environmentliquid-fixpointallow higher order qualifiersliquid-fixpointeliminate non-cut KVarsliquid-fixpoint)maximum length of KVar chain to eliminateliquid-fixpointsmt timeout in msecliquid-fixpointprint eliminate statsliquid-fixpointprint solver statsliquid-fixpoint+print meta-data associated with constraintsliquid-fixpointcompute constraint statisticsliquid-fixpoint&partition FInfo into separate fq filesliquid-fixpointsave FInfo as .bfq and .fq fileliquid-fixpoint3min .fq by delta debug (unsat with min constraints)liquid-fixpoint0min .fq by delta debug (sat with min qualifiers)liquid-fixpoint+min .fq by delta debug (sat with min kvars)liquid-fixpointBshrink final solution by pruning redundant qualfiers from fixpointliquid-fixpointsolve "gradual" constraintsliquid-fixpointinteractive gradual solvingliquid-fixpointignore given kut variables liquid-fixpointTreat non-linear vars as cuts liquid-fixpoint!Disable non-concrete KVar slicing liquid-fixpoint'Allow axiom instantiation via rewriting liquid-fixpointUse incremental PLE liquid-fixpoint&Only check these specific constraints liquid-fixpointKConfiguration Options -----------------------------------------------------3     3      None=>?%*liquid-fixpointImplement either + or ,5liquid-fixpointTop-level pretty printer8liquid-fixpointPlease do not alter this.&'()*,+-./0123456789:;<=30124-./*,+56789:()&';<=None27=?X)]liquid-fixpointBA Reusable SrcSpan Type ------------------------------------------cliquid-fixpointStart Positiondliquid-fixpoint End Positionfliquid-fixpointBLocated Values ---------------------------------------------------vliquid-fixpointBRetrofitting instances to SourcePos ------------------------------]^_`abcedfghijklmnop]^_`fgabcedklnopmhij None%127=?HQVX liquid-fixpoint$Values that can be viewed as Symbolsliquid-fixpointELocated Symbols -----------------------------------------------------liquid-fixpoint Invariant: a  is made up of: '0'..'9'++ [ 'a'...'z'] ++ ['A'..'Z'] ++ ?If the original text has ANY other chars, it is represented as:lq$i+where i is a unique integer (for each text)liquid-fixpointFDecoding Symbols -----------------------------------------------------liquid-fixpointFEncoding Symbols -----------------------------------------------------liquid-fixpointRJ: We allow the extra  unsafeChars to allow parsing encoded symbols. e.g. the raw string "This#is%$inval!d" may get encoded as "enc%12" and serialized as such in the fq/bfq file. We want to allow the parser to then be able to read the above back in.liquid-fixpointHUse this **EXCLUSIVELY** when you want to add stuff in front of a Symbolliquid-fixpoint'testSymbol c' creates the `is-c`& symbol for the adt-constructor named c.liquid-fixpoint NOTE: SymbolTextUse 1 if you want it to machine-readable, but ) if you want it to be human-readable.liquid-fixpoint:Symbols --------------------------------------------------VV None&'247=>?@APliquid-fixpointEmbedding stuff as Sorts liquid-fixpointName of defined datatypeliquid-fixpointNumber of type variablesliquid-fixpointPDatatype Ctors. Invariant: type variables bound in ctors are greater than ddVars liquid-fixpoint Ctor Name liquid-fixpoint Ctor Fieldsliquid-fixpoint Field Nameliquid-fixpoint Field Sortliquid-fixpointKSorts ---------------------------------------------------------------------liquid-fixpointnumeric kind for Num tyvarsliquid-fixpoint"numeric kind for Fractional tyvarsliquid-fixpointuninterpreted typeliquid-fixpointfixpoint type variableliquid-fixpointfunctionliquid-fixpointtype-abstractionliquid-fixpointconstructed type-liquid-fixpointfApp' (FApp (FApp Map key) val) ===> [Map, key, val] That is, fApp'E is used to split a type application into the FTyCon and its args.=liquid-fixpointDExported Basic Sorts ----------------------------------------------->liquid-fixpointDExported Basic Sorts -----------------------------------------------?liquid-fixpointDExported Basic Sorts -----------------------------------------------@liquid-fixpointDExported Basic Sorts -----------------------------------------------Aliquid-fixpointDExported Basic Sorts -----------------------------------------------Bliquid-fixpointDExported Basic Sorts -----------------------------------------------T      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPT0 !#$3G@A=?BCDE>"%&5')F(,*+/-.2HI19:<678;     4LNOPKJM None&'24567=>?@AMQg liquid-fixpointDClass Predicates for Valid Refinements -----------------------------liquid-fixpointDTODO: This doesn't seem to merit a TC ------------------------------liquid-fixpoint'Values that can be viewed as Predicatesliquid-fixpointCGeneralizing Symbol, Expression, Predicate into Classes -----------&Values that can be viewed as Constants(Values that can be viewed as Expressionsliquid-fixpointParsed refinement of Symbol as Expr# e.g. in '{v: _ | e }' v is the Symbol and e the Exprliquid-fixpointKExpressions ---------------------------------------------------------------EUninterpreted constants that are embedded as "constant symbol : Str"liquid-fixpointKSubstitutions -------------------------------------------------------------liquid-fixpointKKvars ---------------------------------------------------------------------liquid-fixpointWrap the enclosed 7, in parentheses only if the condition holds.liquid-fixpointKPredicates ----------------------------------------------------------------'liquid-fixpoint:Refinements ----------------------------------------------+liquid-fixpoint7Gradual Type Manipulation -----------------------------liquid-fixpoint7Generally Useful Refinements --------------------------Cliquid-fixpointKString Constants ----------------------------------------------------------Replace all symbol-representations-of-string-literals with string-literal Used to transform parsed output from fixpoint back into fq.pliquid-fixpoint,The symbol may be an encoding of a SymConst.liquid-fixpoint parameters for Reft, vv + othersliquid-fixpointfree symbols of a1      !"#$%&'()*+,-./01234  /%012 !"-.#$)*'1(34  &+, None247NoneNoneliquid-fixpointKTODO: Rewrite using visitor -----------------------------------------------None 124567=?Xliquid-fixpoint@Result ---------------------------------------------------------liquid-fixpointKA BareBones Error Type ----------------------------------------------------liquid-fixpoint@Catalogue of Errors --------------------------------------------]^_`ik]^_`kiNone&'24567=>?@AMm!liquid-fixpointKConstraint Pack Sets ------------------------------------------------------Fliquid-fixpoint'Functions for Global Binder Environment]liquid-fixpoint&Functions for Indexed Bind Environment7!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW7*$%&8/014236597=>:;<?U+-,@CADEBPSQRO()GFNHLMTIKJ'.!"#VWNone27QA6liquid-fixpointA Refinement of  that describes SMTLIB Sortsliquid-fixpoint/ describes the SMT semantics for a given symbolliquid-fixpoint for UDF: len, height, appendliquid-fixpointfor ADT constructor and tests: cons, nilliquid-fixpointfor ADT tests :  `is$cons`liquid-fixpointfor ADT field: hd, tlliquid-fixpoint for theory ops: mem, cup, selectliquid-fixpoint3 represents the information about each interpreted liquid-fixpointnameliquid-fixpointserialized SMTLIB2 nameliquid-fixpointsortliquid-fixpoint>TRUE = defined (interpreted), FALSE = declared (uninterpreted)liquid-fixpoint is used to resolve the  and  of each liquid-fixpointSorts of *all* defined symbolsliquid-fixpoint)Information about theory-specific Symbolsliquid-fixpointUser-defined data-declarationsliquid-fixpointDistinct Constant symbolsliquid-fixpointTypes at which apply/ was used; see [NOTE:apply-monomorphization]liquid-fixpoint/ is the low-level representation for SMT valuesliquid-fixpointThese are "BUILT-in" polymorphic functions which are UNININTERPRETED but POLYMORPHIC, hence need to go through the apply-defunc stuff.liquid-fixpointsmtSortsP attempts to compute a list of all the input-output sorts at which applications occur. This is a gross hack; as during unfolding we may create _new_ terms with wierd new sorts. Ideally, we MUST allow for EXTENDING the apply-sorts with those newly created terms. the solution is perhaps to *preface* each VC query of the form-push assert p check-sat pop%with the declarations needed to make p3 well-sorted under SMT, i.e. change the above toGdeclare apply-sorts push assert p check-sat popssuch a strategy would NUKE the entire apply-sort machinery from the CODE base. [TODO]: dynamic-apply-declarationliquid-fixpointThe poly parameter is True when we are *declaring* sorts, and so we need to leave the top type variables be; it is False when we are declaring variables etc., and there, we serialize them using b (though really, there SHOULD BE NO floating tyVars... 'smtSort True msg t' serializes a sort tB using type variables, 'smtSort False msg t' serializes a sort t using  instead of tyvars.''None&'247=>?@AMQb)liquid-fixpointname of reflected functionliquid-fixpointnames of parametersliquid-fixpointdefinition of bodyliquid-fixpoint sort of bodyliquid-fixpointis this a recursive definitionliquid-fixpointFAxiom Instantiation Information --------------------------------------liquid-fixpointFTop level Solvers ----------------------------------------------------liquid-fixpointcst id |-> Horn Constraintliquid-fixpoint%Kvar |-> WfC defining its scope/argsliquid-fixpointBind |-> (Symbol, SortedReft)liquid-fixpointSubset of existential bindersliquid-fixpointGlobal Constant symbolsliquid-fixpointDistinct Constant symbolsliquid-fixpointSet of KVars *not* to eliminateliquid-fixpointAbstract domainliquid-fixpointMetadata about bindersliquid-fixpointUser-defined data declarationsliquid-fixpointHigher Order infoliquid-fixpointTODO: what is this?liquid-fixpoint)Information about reflected function defsliquid-fixpoint+Allow higher order binds in the environemntliquid-fixpointAllow higher order qualsliquid-fixpointTop-level Queriesliquid-fixpointKConstraint Cut Sets -------------------------------------------------------liquid-fixpointmatch everything liquid-fixpointstr . $i i.e. match prefix str with suffix bound to $iliquid-fixpoint$i . str i.e. match suffix str with prefix bound to $iliquid-fixpointstr i.e. exactly match strliquid-fixpointKQualifiers ---------------------------------------------------------------- liquid-fixpointName liquid-fixpoint Parameters liquid-fixpoint Predicate liquid-fixpointSource Locationliquid-fixpointSolutions and Results liquid-fixpointId of lhs/rhs binder5liquid-fixpointKConstraints ---------------------------------------------------------------Aliquid-fixpointF"Smart Constructors" for Constraints ---------------------------------Kliquid-fixpointconstructing qualifiersOliquid-fixpointConstructing QueriesRliquid-fixpointRendering QueriesTliquid-fixpoint!Query Conversions: FInfo to SInfo      !"#%$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVTRSUO-./0123487#&B;$%CA !"59:ED6'()*+,    FGKJHI< =@?>NPQVLMNoneiliquid-fixpointCompute the domain of a kvarliquid-fixpointFree variables of a refinementliquid-fixpoint8Split a SortedReft into its concrete and KVar components8Nonej&'()*+,-/.0213456789:;<=]^_`abcedfghijklmnop      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP      !"#$%&'()*+,-./01234!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVW      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVNone=>?MPQ}!liquid-fixpoint:String Constants -----------------------------------------liquid-fixpointCoSub is a map from (coercion) ty-vars represented as 'FObj s' to the ty-vars that they should be substituted with. Note the domain and range are both Symbol and not the Int used for real ty-vars.liquid-fixpointContext ctx8 is built in a "top-down" fashion; not "across" siblingsliquid-fixpointTransforms can access current ctxliquid-fixpoint!Accumulations can access current ctx; acc value is monoidalliquid-fixpointVisitors over Sort!!NoneOliquid-fixpointi ignores the actual refinements as they are not relevant in the kvar parameters (as suggested by BLC.)  None=>? liquid-fixpointKAST Conversion: Types that can be serialized ------------------------------liquid-fixpoint*Information about the external SMT processliquid-fixpoint"Responses received from SMT engineliquid-fixpointKTypes ---------------------------------------------------------------------Commands issued to SMT engine  !"#$%&'()* !"#$%&'() *None=?Q liquid-fixpoint NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------liquid-fixpoint NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------liquid-fixpoint NOTE:Adding-TheoriesVTo add new (SMTLIB supported) theories to liquid-fixpoint and upstream, grep for  Map_default and then add your corresponding symbol in all those places. This is currently far more complicated than it needs to be.KTheory Symbols ------------------------------------------------------------>liquid-fixpointKExported API --------------------------------------------------------------Bliquid-fixpointTheory Symbols :  uninterpSEnv should be disjoint from see  interpSEnv) to avoid duplicate SMT definitions.  uninterpSEnv& is for uninterpreted symbols, and  interpSEnv is for interpreted symbols.BX contains the list of ALL SMT symbols with interpretations, i.e. which are given via  `define-fun` (as opposed to  `declare-fun`)Eliquid-fixpoint'Constructors, Selectors and Tests from  arations.liquid-fixpoint('selfSort d' returns the _self-sort_ of d :: %. See [NOTE:DataDecl] for details.liquid-fixpoint)'fldSort d t' returns the _real-sort_ of d if t- is the _self-sort_ and otherwise returns t". See [NOTE:DataDecl] for details.liquid-fixpoint converts the  into a full &0123456789:;<=>?@ABCDE?>A&BE0123456789:<;=@DCNone275Oliquid-fixpointConstruct the bitvector  from its JQliquid-fixpoint4Apply some bitvector operator to a list of argumentsRliquid-fixpoint Construct an / using a raw string, e.g. (Bv S32 "#x02000000") GHIJKLMNOPQ MNJKLGHIOQPNone =>?@APQlm]liquid-fixpointKAPI for manipulating Sort Substitutions -----------------------------------liquid-fixpointKChecking Refinements ------------------------------------------------------Types used throughout checker_liquid-fixpointElaborate: make polymorphic instantiation explicit via casts, make applications monomorphic for SMTLIB. This deals with polymorphism by `l-ing all refinements except for KVars. THIS IS NOW MANDATORY as sort-variables can be instantiated to $ and bool.aliquid-fixpointKPredicates on Sorts -------------------------------------------------------liquid-fixpoint: adds "casts" to decorate polymorphic instantiation sites.liquid-fixpoint7 replaces all direct function calls indirect calls via rbliquid-fixpointKSort Inference ------------------------------------------------------------eliquid-fixpointKChecking Refinements ------------------------------------------------------liquid-fixpointKChecking Expressions ------------------------------------------------------liquid-fixpointLElaborate expressions with types to make polymorphic instantiation explicit.liquid-fixpoint/defuncEApp monomorphizes function applications.lliquid-fixpoint NOTE:apply-monomorphization^Because SMTLIB does not support higher-order functions, all _non-theory_ function applications EApp e1 e2are represented, in SMTLIB, as(Eapp (EApp apply e1) e2)where r& is 'ECst (EVar "apply") t' and t is 'FFunc a b' a,b are the sorts of e2 and 'e1 e2' respectively.9Note that *all polymorphism* goes through this machinery.7Just before sending to the SMT solver, we use the cast t to generate a special  apply_at_t symbol.$To let us do the above, we populate & with the _set_ of all sorts at which r is used, computed by l.NOTE:coerce-apply'-- related to [NOTE:apply-monomorphism];Haskell's GADTs cause a peculiar problem illustrated below:H```haskell data Field a where FInt :: Field Int FBool :: Field Booltproj :: Field a -> a -> a proj fld x = case fld of FInt -> 1 + x FBool -> not b ```## The Problem-The problem is you cannot encode the body of proj as a well-sorted refinement:s```haskell if is$FInt fld then (1 + (coerce (a ~ Int) x)) else (not (coerce (a ~ Bool) x)) ```The catch is that x is being used BOTH as  and as # which is not supported in SMTLIB.$## Approach: Uninterpreted Functions We encode coerce+ as an explicit **uninterpreted function**:7```haskell if is$FInt fld then (1 + (coerce)(a -> int) x)) else (not (coerce(a -> bool) x)) ```1where we define, extra constants in the style of r ```haskell constant coerce*(a -> int ) :: a -> int constant coerce(a -> bool) :: a -> int ```$However, it would not let us verify: ```haskell5unwrap :: Field a -> a -> a unwrap fld x = proj fld xEtest = unwrap FInt 4 == 5 && unwrap FBool True == False ```because we'd get[```haskell unwrap FInt 4 :: { if is$FInt FInt then (1 + coerce_int_int 4) else ... } ```and the UIF nature of coerce_int_int renders the VC invalid.(## Solution: Eliminate Trivial CoercionsHOWEVER, the solution here, may simply be to use UIFs when the coercion is non-trivial (e.g. `a ~ int`) but to eschew them when they are trivial. That is we would encode:| Expr | SMTLIB | |:-----------------------|:-------------------| | `coerce (a ~ int) x` | `coerce_a_int x` | | `coerce (int ~ int) x` | x |<which, I imagine is what happens _somewhere_ inside GHC too?mliquid-fixpointKExpressions sort ---------------------------------------------------------liquid-fixpoint&Helper for checking symbol occurrencesliquid-fixpoint,Helper for checking if-then-else expressionsliquid-fixpoint$Helper for checking cast expressionsliquid-fixpointHelper for checking uninterpreted function applications | Checking function application should be curried, e.g. | fromJust :: Maybe a -> a, f :: Maybe (b -> b), x: c |- fromJust f x RJ: The above comment makes no sense to me :(liquid-fixpoint/Helper for checking binary (numeric) operationsliquid-fixpointKChecking Predicates -------------------------------------------------------liquid-fixpointChecking Relationsliquid-fixpointSort Unification on Expressionsliquid-fixpointSort Unificationqliquid-fixpoint3Fast Unification; `unifyFast True` is just equalityrliquid-fixpointKApplying a Type Substitution ----------------------------------------------liquid-fixpointKDeconstruct a function-sort -----------------------------------------------liquid-fixpointKError messages ------------------------------------------------------------5=?]^_`abcdefghijklmnopqr]^dhefgibcmnqpor=?_`lkj5aNone&'1279=>?@APQUV "liquid-fixpointA Index is a suitably indexed version of the cosntraints that lets us 1. CREATE a monolithic "background formula" representing all constraints, 2. ASSERT each lhs via bits for the subc-id and formulas for dependent cut KVarsliquid-fixpointBindPred for each BindIdliquid-fixpointDefinition of each liquid-fixpointConstraints defining each liquid-fixpointBinders of each Subcliquid-fixpoint,Transitive closure oof all dependent bindersliquid-fixpointSorts for all symbols , bindPrev :: !(BIndex |-> BIndex) -- ^ "parent" (immediately dominating) binder , kvDeps :: !(CMap [KIndex]) -- ^ List of (Cut) KVars on which a SubC dependsliquid-fixpointEach # corresponds to a conjunction of a  and bpKVarsliquid-fixpointConcrete predicate (PTrue o)liquid-fixpointKVar-Subst pairsliquid-fixpoint7A BIndex is created for each LHS Bind or RHS constraintliquid-fixpointDA KIndex uniquely identifies each *use* of a KVar in an (LHS) binderliquid-fixpointKInstantiated Qualifiers ---------------------------------------------------liquid-fixpointA - is an association list indexed by predicatesliquid-fixpointBinders from defining Envliquid-fixpointSubstitutions from cstrs Rhsliquid-fixpoint Id of defining Cstrliquid-fixpoint(Tag of defining Cstr (DEBUG)liquid-fixpointA C is a single constraint defining a KVar ---------------------------liquid-fixpointA Y contains the various indices needed to compute a solution, in particular, to compute lhsPred for any given constraint.liquid-fixpoint'Environment used to elaborate solutionsliquid-fixpointActual solution (for cut kvar)liquid-fixpointSolution for gradual variablesliquid-fixpoint"Defining cubes (for non-cut kvar)liquid-fixpointSet of allowed binders for kvarliquid-fixpoint$EbindSol for each existential binderliquid-fixpointAn K contains the relevant information for an existential-binder; (See testsposebind-*.fq for examples.) This is either 1. the constraint whose HEAD is a singleton that defines the binder, OR 2. the solved out TERM that we should use in place of the ebind at USES.liquid-fixpoint7The constraint whose HEAD "defines" the Ebind and the Symbol for that EBindliquid-fixpoint0The solved out term that should be used at USES.liquid-fixpointHEBinds not to be solved for (because they're currently being solved for)liquid-fixpointThe = data type --------------------------------------------------liquid-fixpointKUpdate Solution -----------------------------------------------------------liquid-fixpointKCreate a Solution ---------------------------------------------------------liquid-fixpointKRead / Write Solution at KVar ---------------------------------------------GGNone7#liquid-fixpointThe main data typesNone)=>?Q)liquid-fixpointhSMTLIB/Z3 don't like "unused" type variables; they get pruned away and cause wierd hassles. See testspos$adt_poly_dead.fq for an example. ] adds a junk constructor that "uses" up all the tyvars just to avoid this pruning problem.liquid-fixpoint\smt2Cast uses the 'as x T' pattern needed for polymorphic ADT constructors like Nil, see `tests/pos/adt_list_1.fq`None "#=?QX;u  liquid-fixpointxtype ClosedPred E = {v:Pred | subset (vars v) (keys E) } checkValid :: e:Env -> ClosedPred e -> ClosedPred e -> IO Bool liquid-fixpoint~If you already HAVE a context, where all the variables have declared types (e.g. if you want to make MANY repeated Queries)liquid-fixpointKSMT IO --------------------------------------------------------------------liquid-fixpointESMT Context ---------------------------------------------------------liquid-fixpointHSMT Commands -----------------------------------------------------------liquid-fixpointHSMT Commands -----------------------------------------------------------liquid-fixpointb returns {0, 1, 2} where: 0 = Theory-Definition, 1 = Theory-Declaration, 2 = Query-Binderliquid-fixpoint is used solely to determine the set of literals (of each sort) that are *disequal* to each other, e.g. EQ, LT, GT, or string literals "cat", "dog", "mouse". These should only include non-function sorted values.liquid-fixpointZ sorts the data declarations such that each declarations only refers to preceding ones.3  !"#$%&'()    3 !"#$%&'()     None7=>?PQ(liquid-fixpoint@Parsing Constraints (.fq files) --------------------------------?liquid-fixpointIntegerEliquid-fixpointString Haskell infix IdIliquid-fixpointArbitrary SymbolsJliquid-fixpoint(Integer) Constantsliquid-fixpointUsed as input to &Text.Parsec.Expr.buildExpressionParser to create exprPLliquid-fixpoint ExpressionsNliquid-fixpointFunction Applicationsliquid-fixpoint9BitVector literal: lit "#x00000001" (BitVec (Size32 obj))Pliquid-fixpointSortQliquid-fixpointBit-Vector Sortliquid-fixpointKPredicates ----------------------------------------------------------------Sliquid-fixpointKBareTypes -----------------------------------------------------------------RefaTliquid-fixpoint2(Sorted) Refinements with configurable sub-parsersUliquid-fixpointBinder (lowerIdP <* colon)Vliquid-fixpoint(Sorted) RefinementsWliquid-fixpoint((Sorted) Refinements with default binderXliquid-fixpointKParsing Data Declarations -------------------------------------------------[liquid-fixpointKParsing Qualifiers -------------------------------------------------------- Qualifiersliquid-fixpoint@Axioms for Symbolic Evaluation ---------------------------------liquid-fixpoint@Interacting with Fixpoint --------------------------------------GK "!#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`aG "!123456789;:O=>\<CBEIJ?UPKLRN[SVWTQA@GHa_`]FD^,-./0#$%&'()*+MKXYZNone,Smm None24567anliquid-fixpointQuery is an NNF Horn Constraint. pliquid-fixpoint$qualifiers over which to solve cstrsqliquid-fixpointkvars, with parameter-sortsrliquid-fixpointlist of constraintssliquid-fixpoint*list of constants (uninterpreted functionstliquid-fixpoint*list of constants (uninterpreted functionsvliquid-fixpointpwliquid-fixpointc1  ...  cnxliquid-fixpointall x:t. p => cyliquid-fixpoint(exi x:t. p / c or is it exi x:t. p => c?zliquid-fixpointCst is an NNF Horn Constraint. liquid-fixpointHPredM is a Horn predicate that appears as LHS (body) or RHS (head) of constraints liquid-fixpointr liquid-fixpoint $k(y1..yn) liquid-fixpointp1  ... pn liquid-fixpointHVar is a Horn variable liquid-fixpoint"name of the variable $k1, $k2 etc.liquid-fixpoint<sorts of its parameters i.e. of the relation defined by the HVarliquid-fixpoint meta-datanopqrstuyxvwz{~|}nopqrstuyxvwz{~|}!None4fliquid-fixpointA HThing[ describes the kinds of things we may see, in no particular order in a .smt2 query file.liquid-fixpoint Qualifiersliquid-fixpointHorn Variables liquid-fixpointHelpers "None24567iliquid-fixpoint?Data types and helpers for manipulating information about KVarsliquid-fixpointgoSO recursively traverses the NNF constraint to build up a list of the vanilla SubC constraints.#None7~liquid-fixpointx contains all the stuff needed to produce a result, and is the the essential ingredient of the state needed by solve_liquid-fixpointthe initial solutionliquid-fixpointthe whole input queryliquid-fixpoint+dependencies between constraints/ranks etc.liquid-fixpoint"set of KVars to actually solve forliquid-fixpointKRanks ---------------------------------------------------------------------liquid-fixpoint SCC number with ALL dependenciesliquid-fixpoint#SCC number without CUT dependenciesliquid-fixpointThe constraint's Tagliquid-fixpointKConstraint Dependencies ---------------------------------------------------liquid-fixpoint!Constraints *written by* a SubcIdliquid-fixpoint!(Cut) KVars *read by* a SubcIdliquid-fixpointSCC rank of a SubcIdliquid-fixpointTotal number of Sccsliquid-fixpoint)F.SubcIds that transitively "reach" belowliquid-fixpointF.SubcIds with Concrete RHSliquid-fixpointDependencies between slKVarCsliquid-fixpointDramatis Personaeliquid-fixpointreal kvar vertexliquid-fixpoint)dummy to ensure each kvar has a successorliquid-fixpoint1existentially bound "ghost paramter" to solve forliquid-fixpoint(constraint-id which creates a dependencyliquid-fixpointFCMap API -------------------------------------------------------------/&/&$Noneliquid-fixpoint? is representation of the KVGraph with a fast succ, pred lookupliquid-fixpointout-edges of a liquid-fixpointin-edges of a   %None"#,PUVliquid-fixpoint0number of kvars whose removal makes deps acyclicliquid-fixpoint,number of kvars that appear >= 2 in some LHSliquid-fixpointnumber of kvarsliquid-fixpointis dep-graph reducibleliquid-fixpointset of non-linear kvarsliquid-fixpointKGeneric Dependencies ------------------------------------------------------liquid-fixpointmCompute constraints that transitively affect target constraints, and delete everything else from F.SInfo aliquid-fixpointDO NOT DELETE! sliceCSucc :: Slice -> CSucc sliceCSucc sl = i -> M.lookupDefault [] i im where im = M.fromList [(i, is) | (i,_,is) <- slEdges sl]liquid-fixpointKConstraint Graph ----------------------------------------------------------liquid-fixpointKRanks from Graph ----------------------------------------------------------liquid-fixpointKDependencies --------------------------------------------------------------liquid-fixpointEliminated Dependenciesliquid-fixpoint0 "eliminates" a kvar k by replacing every "path"ki -> ci -> k -> c with an edgeki ------------> cliquid-fixpointKCompute Dependencies and Cuts ---------------------------------------------liquid-fixpoint returns an t that renders the dependency graph acyclic by picking _at least one_ kvar from each non-trivial SCC in the graphliquid-fixpoint extends the input  by adding kuts that ensure that the *maximum distance* between an eliminated KVar and a cut KVar is *upper bounded* by a given threshold.  &None,6liquid-fixpointType alias for a function to construct a partition. mkPartition and mkPartition' are the two primary functions that conform to this interfaceliquid-fixpointKMulticore info ------------------------------------------------------------liquid-fixpointKConstraint Partition Container -------------------------------------------- liquid-fixpointPartition an FInfo into multiple disjoint FInfos. Info is Nothing to produce the maximum possible number of partitions. Or a MultiCore Info to control the partitioning liquid-fixpointYPartition an FInfo into a specific number of partitions of roughly equal amounts of workliquid-fixpointfReturn the "size" of a CPart. Used to determine if it's substantial enough to be worth parallelizing.liquid-fixpointConvert a CPart to an FInfoliquid-fixpointConvert an FInfo to a CPartliquid-fixpoint"typically a F.FInfo a or F.CPart a liquid-fixpoint)describes thresholds and partiton amountsliquid-fixpointThe originial FInfoliquid-fixpoint&A list of the smallest possible CPartsliquid-fixpoint,At most N partitions of at least thresh workliquid-fixpointmkPartition or mkPartition'liquid-fixpoint  F.FInfo aor [F.CPart a]          9NoneI&m     'None7F(NoneP liquid-fixpoint Constraint Idliquid-fixpointTime at which insertedliquid-fixpointRank of constraintliquid-fixpointFWorkItems ------------------------------------------------------------liquid-fixpointKWorklist ------------------------------------------------------------------liquid-fixpointKInitialize worklist and slice out irrelevant constraints ------------------liquid-fixpointFCandidate Constraints to be checked AFTER computing Fixpoint ---------liquid-fixpoint Pending APIliquid-fixpointFSet API --------------------------------------------------------------)NonePliquid-fixpointw computes the "real" domain of each kvar, which is a SUBSET of the input domain, in which we KILL the parameters x@ which appear in substitutions of the form `K[x := y]` where y is not in the env.liquid-fixpointdropAdtMeasures removes all the measure definitions that correspond to constructor, selector or test names for declared datatypes, as these are now "natively" handled by the SMT solver.liquid-fixpointS traverses the constraints to find (string) literals that are then added to the dLits field.liquid-fixpointSee issue liquid-fixpoint issue #230. This checks that whenever we have, G1 |- K.su1 G2, K.su2 |- rhs then G1 cap G2 subseteq wenv(k)(liquid-fixpoint( removes dead `K[x := e]` where x NOT in the domain of K.liquid-fixpointz updates the kvar-domains in the wf constraints to a subset of the original binders, where we DELETE the parameters x= which appear in substitutions of the form `K[x := y]` where y is not in the env.liquid-fixpoint*`restrictWf kve k w` restricts the env of w to the parameters in `kve k`.liquid-fixpoint;check that no constraint has free variables (ignores kvars)liquid-fixpoint*check that no qualifier has free variablesliquid-fixpoint=check that each constraint has RHS of form [k1,...,kn] or [p])liquid-fixpoint1symbol |-> sort for EVERY variable in the SInfo; ) can ONLY be called with **sanitized** environments (post the uniqification etc.) or else you get duplicate sorts and other such errors. We do this peculiar dance with env0I to extract the apply-sorts from the function definitions inside the AxiomEnvg which cannot be elaborated as it makes it hard to actually find the fundefs within (breaking PLE.)liquid-fixpointDrop func-sorted bind that are shadowed by constant (if same type, else error)liquid-fixpoint-Drop irrelevant binders from WfC Environmentsliquid-fixpoint nonDerivedLH* keeps a bind x if it does not start with  which is used typically for names that are automatically "derived" by GHC (and which can) blow up the environments thereby clogging instantiation, etc. NOTE: This is an LH specific hack and should be moved there.liquid-fixpoint+Generic API for Deleting Binders from FInfoliquid-fixpoint0Replace KVars that do not have a WfC with PFalse'()')(*None&'27=>?@APQUV*liquid-fixpointISubstitute Gradual Solution ---------------------------------------------liquid-fixpointJThe Unique Monad ---------------------------------------------------------.liquid-fixpointIMake each gradual appearence unique -------------------------------------liquid-fixpointJexpandWF -----------------------------------------------------------------*+,-..-,*++None7Qliquid-fixpointA e maps an old name and sort to new name, represented by a hashmap containing association lists. 3 as new name means the name is the same as the old.liquid-fixpointAn  stores for each constraint and BindId the set of other BindIds that it references, i.e. those where it needs to know when their names gets changedliquid-fixpointBind identifierliquid-fixpointConstraint identifier? liquid-fixpoint G replaces the refinements of "unused" binders with "true". see testspos5unused.fq for an example of why this phase is needed. liquid-fixpoint ] seems to do the actual work of renaming all the binders to use their sort-specific names.@@,None=?PQ 1 liquid-fixpointHInformation about size of formula corresponding to an "eliminated" KVar.Eliquid-fixpointKInitial Solution (from Qualifiers and WF constraints) ---------------------Fliquid-fixpoint@Predicate corresponding to LHS of constraint in current solution liquid-fixpoint/`cubePred g s k su c` returns the predicate for(k . su)defined by using cubec := [b1,...,bn] |- (k . su')in the binder environment g.Dbs' := the subset of "extra" binders in [b1...bn] that are *not* in gB p' := the predicate corresponding to the "extra" binders liquid-fixpoint cubePredExc computes the predicate for the subset of binders bs'. The output is a tuple, `(xts, psu, p, kI)` such that the actual predicate we want is `Exists xts. (psu / p)`. liquid-fixpoint substElim returns the binders that must be existentially quantified, and the equality predicate relating the kvar-"parameters" and their actual values. i.e. givenK[x1 := e1]...[xn := en]Awhere e1 ... en have types t1 ... tn we want to quantify outx1:t1 ... xn:tnand generate the equality predicate && [x1 ~~ e1, ... , xn ~~ en] we use ~~ because the param and value may have different sorts, see:testsposkvar-param-poly-00.hs*Finally, we filter out binders if they are Y"free" in e1...en i.e. in the outer environment. (Hmm, that shouldn't happen...?)hare binders corresponding to sorts (e.g. `a : num`, currently used to hack typeclasses current.) liquid-fixpoint ; constructs the information about the "ebind-definitions". EFEF-None77 liquid-fixpoint# Horn ConstraintsNliquid-fixpoint# Refine Iterations liquid-fixpoint # smtBracket calls (push/pop) liquid-fixpoint# smtCheckUnsat calls liquid-fixpoint# times SMT said RHS Valid liquid-fixpointSMT Solver Context liquid-fixpointAll variables and types liquid-fixpointSolver StatisticsOliquid-fixpointKSolver Monadic API --------------------------------------------------------Rliquid-fixpointKSMT Interface -------------------------------------------------------------Z`filterRequired [(x1, p1),...,(xn, pn)] q` returns a minimal list [xi] s.t. / [pi] => qSliquid-fixpointJ`filterValid p [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]`Tliquid-fixpointo`filterValidGradual ps [(x1, q1),...,(xn, qn)]` returns the list `[ xi | p => qi]` | for some p in the list ps MNOPQRSTUVWX OPQRSTVUMXWN.None=?PW]liquid-fixpointKInitial Gradual Solution (from Qualifiers and WF constraints) -------------]]/None=>?PQ  liquid-fixpoint'allow higher order thus defunctionalize liquid-fixpoint/lambda expressions appearing in the expressions liquid-fixpoint$redexes appearing in the expressions liquid-fixpointsorts of new lambda-binders^liquid-fixpointKContainers defunctionalization -------------------------------------------- liquid-fixpointXExpressions defunctionalization -------------------------------------------------------- liquid-fixpointKLow level monad manipulation ----------------------------------------------^_`a`^_a0None "#%=?EPQXhT liquid-fixpointKnowledge (SMT Interaction) liquid-fixpoint*Measure info, asserted for each new Ctor ( ) liquid-fixpoint.(Recursive) function definitions, used for PLE liquid-fixpoint NOTE: Eval-IteWe should not be doing any PLE/eval under if-then-else where the guard condition does not provably hold. For example, see issue #387. However, its ok and desirable to   in this case, as long as one is not unfolding recursive functions. To permit this, we track the "call-stack" and whether or not,  | is occurring under an unresolved guard: if so, we do not expand under any function that is already on the call-stack. liquid-fixpointbUnfold is the result of running PLE at a single equality; (e, [(e1, e1')...]) is the source |e@ and the (possible empty) list of PLE-generated equalities (e1, e1') ... type Unfold = (Maybe Expr, [(Expr, Expr)]) liquid-fixpointInstRes( is the final result of PLE; a map from BindId( to the equations "known" at that BindId liquid-fixpointICtxM is the local information -- at each trie node -- obtained by incremental PLE liquid-fixpoint,Hypotheses, already converted to SMT format liquid-fixpoint Candidates for unfolding liquid-fixpointKnown equalities liquid-fixpoint#Terms that we have already expanded !liquid-fixpointInstEnv, has the global information needed to do PLEpliquid-fixpoint+Strengthen Constraint Environments via PLE "liquid-fixpointNew  Incremental PLE #liquid-fixpoint Step 1a: instEnv) sets up the incremental-PLE environment $liquid-fixpoint Step 1b: mkCTrie builds the Trie. of constraints indexed by their environments %liquid-fixpointStep 2: pleTrie walks over the CTrie# to actually do the incremental-PLE &liquid-fixpointple11 performs the PLE at a single "node" in the Trie 'liquid-fixpointStep 3: resSInfo uses incremental PLE result InstRes# to produce the strengthened SInfo (liquid-fixpointupdCtx env ctx delta cidMb* adds the assumptions and candidates from delta and cidMb to the context. )liquid-fixpointOld GLOBAL PLE *liquid-fixpointSymbolic Evaluation with SMT +liquid-fixpoint + also evaluates all the partial applications for hacky reasons, suppose `foo g = id` then we want `foo g 10 = 10` and for that we need to   the term `foo g` into  , to tickle the   on `id 10`. This seems a bit of a hack. At any rate, this can lead to divergence. TODO: distill a .fq test from the MOSSAKA-hw3 example. -liquid-fixpoint$Minimal test case illustrating this  - hack is LH#testsplecpos/MossakaBug.hs too tired & baffled to generate simple .fq version. TODO:nuke and rewrite PLE! .liquid-fixpoint . unfolds or instantiates an equation at a particular list of argument values. We must also substitute the sort-variables that appear as coercions. See testsproofple1.fq /liquid-fixpointThis creates the rewrite rule e1 -> e2, applied when: 1. when e2 is a DataCon and can lead to further reductions 2. when size e2 < size e1 liquid-fixpointCreating Measure Info 0liquid-fixpointin "reverse" order *liquid-fixpoint Definitionsliquid-fixpointEnvironment of "true" facts liquid-fixpointCandidates for unfolding liquid-fixpoint Constraint Idliquid-fixpointNewly unfolded equalitiespp1None>X 1liquid-fixpoint Map each 6 to the list of constraints on which it appears on RHSvliquid-fixpointv constructs a \ comprising the Solution and various indices needed by the worklist-based refinement loopvv2None=>?PQe 2liquid-fixpoint Progress Bar 3liquid-fixpointtidyResult ensures we replace the temporary kVarArg names introduced to ensure uniqueness with the original names in the given WF constraints. 4liquid-fixpointFSingle Step Refinement ----------------------------------------------- 5liquid-fixpointKConvert Solution into Result ---------------------------------------------- 6liquid-fixpoint 6\ transforms each KVar's result by removing conjuncts that are implied by others. That is,<minimizeConjuncts :: ps:[Pred] -> {qs:[Pred] | subset qs ps}ssuch that `minimizeConjuncts ps` is a minimal subset of ps where no is implied by /_{q' in qs qs} see: testsposmin00.fq for an example. 7liquid-fixpoint@Predicate corresponding to RHS of constraint in current solution 8liquid-fixpointJInteraction with the user when Solving -----------------------------------wxwx3NoneXfKyz{yz{4NoneXq|liquid-fixpointFSolve an .fq file ----------------------------------------------------~liquid-fixpointKSolve FInfo system of horn-clause constraints ----------------------------- 9liquid-fixpointCSolve in parallel after partitioning an FInfo to indepdendant parts :liquid-fixpointCSolve in parallel after partitioning an FInfo to indepdendant parts ;liquid-fixpointESolve a list of FInfos using the provided solver function in parallel <liquid-fixpointKNative Haskell Solver ----------------------------------------------------- =liquid-fixpointKNative Haskell Solver -----------------------------------------------------liquid-fixpointKParse External Qualifiers -------------------------------------------------|}~~|}5None=?PQ_ >liquid-fixpoint-uniq makes sure each binder has a unique name ?liquid-fixpointflatten removes redundant  @s and empty conjuncts.?For example: >>> :{ flatten $ doParse' hCstrP "" "(forall ((VV# 15 int) (VV 15 == anfA#3)) ((and (and ($k13 VV#15 anf3 moo5#5) (true)))))" :} (forall ((VV# 15 int) (VV 15 == anf 3)) ((k13 VV15 anf3 moo#5)))liquid-fixpointsolveEbs has some preconditions - pi -> k -> pi structure. That is, there are no cycles, and while ks can depend on other ks, pis cannot directly depend on other pis - predicate for exists binder is true. This doesn't seem hard to lift, but I just haven't tested it/thought too hard about what the correct behavior in this case is. - There is at least one ebind Aliquid-fixpointjCollects the defining constraint for  AKA c in forall n. => c additionally collects the variable name n Bliquid-fixpoint>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind01.smt2"F.pprint $ pokec (qCstr q) (and (forall ((m int) (true)) (and (forall ((x1 int) (x1 x1)) (and# (forall ((v int) (v == m + 1)) (((v == x1))))$ (forall ((v int) (v == x1 + 1)) (((v == 2 + m)))))) (exists ((x1 int) (true)) ((x1 x1))))))>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind02.smt2"F.pprint $ pokec (qCstr q)(and (forall ((m int) (true)) (forall ((z int) (z == m - 1)) (and$ (forall ((v1 int) (v1 == z + 2)) ((k v1))) (and (forall ((x1 int) (x1 x1)) (and (forall ((v2 int) (k v2)) (((v2 == x1))))( (forall ((v3 int) (v3 == x1 + 1)) (((v3 == m + 2)))))) (exists ((x1 int) (true)) ((x1 x1))))))))flet c = doParse' hCstrP "" "(forall ((a Int) (p a)) (exists ((b Int) (q b)) (and (($k a)) (($k b)))))"F.pprint $ pokec c(forall ((a int) (p a)) (and (forall ((b int) (b b)) (and ((k a)) ((k b)))) (exists ((b int) (q b)) ((b b))))) Cliquid-fixpoint>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind01.smt2"F.pprint $ qCstr q(and (forall ((m int) (true)) (exists ((x1 int) (true)) (and" (forall ((v int) (v == m + 1)) (((v == x1))))# (forall ((v int) (v == x1 + 1)) (((v == 2 + m))))))))6let (Just noside, Just side) = split $ pokec $ qCstr q F.pprint side(forall ((m int) (true)) (exists ((x1 int) (true)) ((x1 x1))))F.pprint noside(forall ((m int) (true)) (forall ((x1 int) (x1 x1)) (and! (forall ((v int) (v == m + 1)) (((v == x1))))" (forall ((v int) (v == x1 + 1)) (((v == 2 + m)))))))>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind02.smt2"F.pprint $ qCstr q (and (forall ((m int) (true)) (forall ((z int) (z == m - 1)) (and$ (forall ((v1 int) (v1 == z + 2)) ((k v1))) (exists ((x1 int) (true)) (and (forall ((v2 int) (k v2)) (((v2 == x1))))' (forall ((v3 int) (v3 == x1 + 1)) (((v3 == m + 2))))))))))6let (Just noside, Just side) = split $ pokec $ qCstr q F.pprint side(forall ((m int) (true)) (forall ((z int) (z == m - 1)) (exists ((x1 int) (true)) ((x1 x1)))))F.pprint noside (forall ((m int) (true)) (forall ((z int) (z == m - 1)) (and# (forall ((v1 int) (v1 == z + 2)) ((k v1))) (forall ((x1 int) (x1 x1)) (and (forall ((v2 int) (k v2)) (((v2 == x1))))& (forall ((v3 int) (v3 == x1 + 1)) (((v3 == m + 2)))))))))liquid-fixpoint>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind01.smt2"6let (Just noside, Just side) = split $ pokec $ qCstr q)F.pprint $ elimPis ["x1"] (noside, side )(forall ((m int) (true))$ (forall ((x1 int) (forall [v : int] . v == m + 1 => v == x1&& forall [v : int]" . v == x1 + 1 => v == 2 + m)) (and! (forall ((v int) (v == m + 1)) (((v == x1))))" (forall ((v int) (v == x1 + 1))3 (((v == 2 + m))))))) : (forall ((m int) (true))5 (exists ((x1 int) (true))/ ((forall [v : int]8 . v == m + 1 => v == x12 && forall [v : int]C . v == x1 + 1 => v == 2 + m))))>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind02.smt2"6let (Just noside, Just side) = split $ pokec $ qCstr q)F.pprint $ elimPis ["x1"] (noside, side )(forall ((m int) (true)) (forall ((z int) (z == m - 1)) (and# (forall ((v1 int) (v1 == z + 2)) ((k v1)))' (forall ((x1 int) (forall [v2 : int]1 . $k[fix$36$$954$arg$36$k$35$1:=v2] => v2 == x1&& forall [v3 : int]$ . v3 == x1 + 1 => v3 == m + 2)) (and (forall ((v2 int) (k v2)) (((v2 == x1))))& (forall ((v3 int) (v3 == x1 + 1))8 (((v3 == m + 2))))))))) : (forall ((m int) (true))? (forall ((z int) (z == m - 1)); (exists ((x1 int) (true))6 ((forall [v2 : int]V . $k[fix$36$$954$arg$36$k$35$1:=v2] => v2 == x19 && forall [v3 : int]L . v3 == x1 + 1 => v3 == m + 2))))) Dliquid-fixpoint$The defining constraints for a pivar@The defining constraints are those that bound the value of pi_x.We're looking to lower-bound the greatest solution to pi_x. If we eliminate pivars before we eliminate kvars (and then apply the kvar solutions to the side conditions to solve out the pis), then we know that the only constraints that mention pi in the noside case are those under the corresponding pivar binder. A greatest solution for this pivar can be obtained as the _weakest precondition_ of the constraints under the binderThe greatest Pi that implies the constraint under it is simply that constraint itself. We can leave off constraints that don't mention n, see +https://photos.app.goo.gl/6TorPprC3GpzV8PL7OActually, we can really just throw away any constraints we can't QE, can't we?:{ let c = doParse' hCstrP "" "\,\(forall ((m int) (true)) \,\ (forall ((x1 int) (and (true) (x1 x1))) \,\ (and \,\ (forall ((v int) (v == m + 1)) \,\ (((v == x1)))) \,\ (forall ((v int) (v == x1 + 1)) \\ (((v == 2 + m)))))))":}F.pprint $ defs "x1" c Just (and$ (forall ((v int) (v == m + 1)) ((v == x1)))% (forall ((v int) (v == x1 + 1)) ((v == 2 + m))))>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind02.smt2".let (Just noside, _) = split $ pokec $ qCstr qF.pprint $ defs "x1" noside Just (and (forall ((v2 int) (k v2)) ((v2 == x1)))' (forall ((v3 int) (v3 == x1 + 1)) ((v3 == m + 2)))) Eliquid-fixpoint>(q, opts) <- parseFromFile hornP "tests/horn/pos/ebind02.smt2"6let (Just noside, Just side) = split $ pokec $ qCstr q7F.pprint $ elimKs ["k"] $ elimPis ["x1"] (noside, side)(forall ((m int) (true)) (forall ((z int) (z == m - 1)) (and# (forall ((v1 int) (v1 == z + 2)) ((true)))' (forall ((x1 int) (forall [v2 : int] . exists [v1 : int] . (v2 == v1)" && v1 == z + 2 => v2 == x1&& forall [v3 : int]$ . v3 == x1 + 1 => v3 == m + 2)) (and% (forall ((v1 int) (v1 == z + 2))# (forall ((v2 int) (v2 == v1)) (((v2 == x1)))))& (forall ((v3 int) (v3 == x1 + 1))8 (((v3 == m + 2))))))))) : (forall ((m int) (true))? (forall ((z int) (z == m - 1)); (exists ((x1 int) (true))6 ((forall [v2 : int]: . exists [v1 : int]7 . (v2 == v1)G && v1 == z + 2 => v2 == x19 && forall [v3 : int]L . v3 == x1 + 1 => v3 == m + 2)))))<Takes noside, side, piSols and solves a set of kvars in them Fliquid-fixpointKQuantifier elimination for use with implicit solver qe :: Cstr a -> Cstr aliquid-fixpointWelim solves all of the KVars in a Cstr (assuming no cycles...) >>> elim . qCstr . fst  $ parseFromFile hornP "testshornpos/test00.smt2" (and (forall ((x int) (x > 0)) (forall ((y int) (y > x)) (forall ((v int) (v == x + y)) ((v > 0)))))) >>> elim . qCstr . fst  $ parseFromFile hornP "testshornpos/test01.smt2" (and (forall ((x int) (x > 0)) (and (forall ((y int) (y > x)) (forall ((v int) (v == x + y)) ((v > 0)))) (forall ((z int) (z > 100)) (forall ((v int) (v == x + z)) ((v > 100))))))) >>> elim . qCstr . fst  $ parseFromFile hornP "testshorn pos/test02.smt2" (and (forall ((x int) (x > 0)) (and (forall ((y int) (y > x + 100)) (forall ((v int) (v == x + y)) ((true)))) (forall ((y int) (y > x + 100)) (forall ((v int) (v == x + y)) (forall ((z int) (z == v)) (forall ((v int) (v == x + z)) ((v > 100))))))))) Gliquid-fixpointSsc <- scope "k0" . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test02.smt2"scO(forall ((x ... (and (forall ((y ... (forall ((v ... ((k0 v)))) (forall ((z ... Hliquid-fixpointA solution is a Hyp of binders (including one anonymous binder that I've singled out here). (What does Hyp stand for? Hypercube? but the dims don't line up...)Ec <- qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test02.smt2"sol1 ("k0") (scope "k0" c)N[[((y int) (y > x + 100)),((v int) (v == x + y)),((_ bool) (arg$k0#1 == v))]]Ec <- qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test03.smt2"sol1 ("k0") (scope "k0" c)[[((x int) (x > 0)),((v int) (v == x)),((_ bool) (arg$k0#1 == v))],[((y int) (k0 y)),((v int) (v == y + 1)),((_ bool) (arg$k0#1 == v))]]flet c = doParse' hCstrP "" "(forall ((a Int) (p a)) (forall ((b Int) (q b)) (and (($k a)) (($k b)))))" sol1 "k" c{[[((a int) (p a)),((b int) (q b)),((_ bool) (arg$k#1 == a))],[((a int) (p a)),((b int) (q b)),((_ bool) (arg$k#1 == b))]] Iliquid-fixpointALET c = doParse' hCstrP "" "(forall ((z Int) ($k0 z)) ((z = x)))"hdoelim "k0" [[Bind "v" F.boolSort (Reft $ F.EVar "v"), Bind "_" F.boolSort (Reft $ F.EVar "donkey")]] c>(forall ((v bool) (v)) (forall ((z int) (donkey)) ((z == x)))) Jliquid-fixpoint@Returns a list of KVars with their arguments that are present asNboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/ebind01.smt2"... []NboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/ebind02.smt2" ... ["k"]MboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test00.smt2"... []MboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test01.smt2"... []MboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test02.smt2" ... ["k0"]MboundKvars . qCstr . fst <$> parseFromFile hornP "tests/horn/pos/test03.smt2" ... ["k0"] Kliquid-fixpointGReturns true if the constraint does not contain any existential binders6None3 L:;<:;=:;>:;?:@ABCDBCEBCFBCGBCHBCIBCJBCKBCLBCMBCNBCOBCPBCQBCRBCSBCTBCUBCVBCWBCXBCYBCZBC[BC\BC]BC^BC_BC`BCaBCbBCcBCdBCeBCfBCgBChBCiBCjBCkBClBCmBCnBCoBCpBCqBCrBCsBCtBCuBCvBwxBwyBwzBw{Bw|Bw}Bw~BwBwBwBwBwBwBwBwp      !"#$%&'()*++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab c d e e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < < = > ? @ 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 [ \ ] ^ _ ` 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 { | } ~                                                                                                                                                                      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` 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:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNNOPQRSTUVWXYYZ[\]^^_`abcdefghijklmnopqrstuvwxyz{|}~4       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFG)HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQQRSTUVWX\[YZnlmZ[\b]^_`abcdefghijklmnopqrstuvwxyz{|}~           $                                               !!"""######################################/###################$$$$$$$$$$$%%%%%%%%%%%%%% % % & & & &&&&&&&&&&&&&&'''''( (!("(#($(%(&( ('((()(*(+((,(-).)/)0*1*2*3*4*5*6*7*8*9*:*;*<*=*>*?*@*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-[-<-\- ---.#/]/^/_/`/a/b/c/d/e/f/g/h/i/j/k/l/m/n0o0p0q0r0s0t1u2v2u3w3x3y4z4{4v4|4}5~55555555555555566v77777777     !!!!""%%%%%%%%%%%&&&&&(((((()))))))))))))))**++++ + + , , , , , - - - - - - - / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 0 !0 "0 #0 $0 %0 &0 '0 (0 )0 *0 + ,0 -0 .0 /0 012 12 22 322 42 52 64 74 84 94 :4 ;55 < = >5 ?5 @5 A5 B5 C5 D5 E5 F5 G5 H5 I J.liquid-fixpoint-0.8.0.2-JBYKSUH26o01SpAxHsWEYdLanguage.Fixpoint.ParseLanguage.Fixpoint.Types.Spans Text.PrettyPrint.HughesPJ.Compat Language.Fixpoint.Utils.ProgressLanguage.Fixpoint.Utils.TrieLanguage.Fixpoint.MiscLanguage.Fixpoint.Utils.FilesLanguage.Fixpoint.Types.Config#Language.Fixpoint.Types.PrettyPrintLanguage.Fixpoint.Types.NamesLanguage.Fixpoint.Types.Sorts#Language.Fixpoint.Types.Refinements Language.Fixpoint.Types.Triggers!Language.Fixpoint.Types.Templates%Language.Fixpoint.Types.SubstitutionsLanguage.Fixpoint.Types.Errors$Language.Fixpoint.Types.Environments Language.Fixpoint.Types.Theories#Language.Fixpoint.Types.ConstraintsLanguage.Fixpoint.Types.UtilsLanguage.Fixpoint.Types.Visitor%Language.Fixpoint.Solver.UniqifyKVarsLanguage.Fixpoint.Smt.TypesLanguage.Fixpoint.Smt.TheoriesLanguage.Fixpoint.Smt.BitvectorLanguage.Fixpoint.SortCheck!Language.Fixpoint.Types.Solutions$Language.Fixpoint.Solver.TrivialSortLanguage.Fixpoint.Smt.SerializeLanguage.Fixpoint.Smt.Interface!Language.Fixpoint.Graph.ReducibleLanguage.Fixpoint.Horn.TypesLanguage.Fixpoint.Horn.ParseLanguage.Fixpoint.Horn.InfoLanguage.Fixpoint.Graph.TypesLanguage.Fixpoint.Graph.IndexedLanguage.Fixpoint.Graph.Deps!Language.Fixpoint.Graph.Partition"Language.Fixpoint.Utils.Statistics!Language.Fixpoint.Solver.Worklist!Language.Fixpoint.Solver.Sanitize Language.Fixpoint.Types.Graduals%Language.Fixpoint.Solver.UniqifyBinds!Language.Fixpoint.Solver.SolutionLanguage.Fixpoint.Solver.Monad(Language.Fixpoint.Solver.GradualSolution!Language.Fixpoint.Defunctionalize$Language.Fixpoint.Solver.Instantiate"Language.Fixpoint.Solver.EliminateLanguage.Fixpoint.Solver.SolveLanguage.Fixpoint.MinimizeLanguage.Fixpoint.Solver&Language.Fixpoint.Horn.TransformationsLanguage.Fixpoint.Horn.SolvePaths_liquid_fixpointLanguage.Fixpoint.TypesLanguage.Fixpoint.Graphparsec-3.1.13.0Text.Parsec.Expr AssocRight AssocLeft AssocNoneAssocText.Parsec.Pos SourcePospretty-1.1.3.6Text.PrettyPrint.HughesPJ fullRender renderStylerenderfsepfcatcatsep<+>$+$$$ punctuatehangnestvcathsephcat reduceDocmaybeDoubleQuotes maybeQuotes maybeBraces maybeBrackets maybeParensbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmptyempty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstylePStrStrChr TextDetailsribbonsPerLine lineLengthmodeStyle OneLineModeLeftMode ZigZagModePageModeMode withProgress progressInit progressTick progressCloseBranchBindValTrieNodeinsertfromListfoldfoldM $fEqBranch $fShowBranch$fEqTrie $fShowTrie<->EqHashListNEMoodsOkLoudSadHappyAngry|-> firstMaybe asyncMapM traceShowhashMapToAscList findNearestargMinheadMb getUniqueInt editDistance moodColor wrapStars withColor colorStrLn colorPhaseLn startPhasedoneLine donePhase putBlankLnwraprepeatserrorP errorstarfst3snd3thd3secondMmlookup safeLookup mfromJustinsertsremovescountgroup groupBase groupListgroupMapallMaphashNubsortNubnubOrd hashNubWith duplicatessafeZip safeZipWith safeFromListsafeHeadsafeLastsafeInit safeUncons safeUnsnocexecuteShellCommand applyNonNullarrowdcolon interspersetshow writeLoud ensurePath singletonpairtriplefMwhenMifM mapEitherisRightcomponentsWith topoSortWithsccsWithexTopocoalesce coalesceEdgesmapFstmapSndallCombinationspowerset=>><<=<$$>revMapMnubDifffold1MExtCgiFqOutHtmlAnnotVimHsHsBootLHsJsTsSpecBinSpecHqualsResultCstMkdnJsonSavedCacheDotPartAutoPredPAssDatBinFqSmt2MinMinQualsMinKVarsgetFixpointPath getZ3LibPathwithExt extFileName tempDirectory extFileNameR isExtFile extModuleName copyFiles getFileInDirsisBinary$fEqExt$fOrdExt $fShowExt EliminateNoneSomeAllHorn Existentials SMTSolverZ3Cvc4MathsatConfigsrcFilecores minPartSize maxPartSizesolverlinear stringTheory defunctionallowHO allowHOqs eliminate elimBound smtTimeout elimStats solverStatsmetadatastatspartssaveminimize minimizeQs minimizeKs minimalSolgradual ginteractiveautoKuts nonLinCutsnoslice rewriteAxioms noIncrPle checkCstr withPragmasdefaultMinPartSizedefaultMaxPartSizeuseElim defConfiggetOpts multicore queryFile$fShowSMTSolver$fDefaultSMTSolver$fShowEliminate$fDefaultEliminate$fSerializeEliminate$fDefaultConfig $fEqSMTSolver$fDataSMTSolver$fGenericSMTSolver $fEqEliminate$fDataEliminate$fGenericEliminate $fEqConfig $fDataConfig $fShowConfig$fGenericConfigPTableptableDocTablePPrint pprintTidy pprintPrecTidyLossyFullFixpointtoFixsimplifytraceFixshowFixpprintshowpp showTabletracepp notracepp pprintKVsboxHSepboxDocdocBox$fFixpointDouble$fFixpointInteger $fFixpointInt$fFixpointBool$fFixpoint(,,) $fFixpoint(,) $fFixpoint[]$fFixpointMaybe $fFixpoint()$fFixpointHashSet $fPPrintText$fPPrintInteger $fPPrintInt $fPPrint() $fPPrintFloat $fPPrintBool $fPPrint(,)$fPPrint(,,,,) $fPPrint(,,,) $fPPrint(,,)$fPPrintHashMap$fPPrintHashSet $fPPrint[] $fPPrintMaybe$fPPrintEither $fPPrintDoc$fPPrintDocTable$fMonoidDocTable$fSemigroupDocTable$fEqTidy $fOrdTidySrcSpanSSsp_startsp_stopLocatedLocloclocEvalsrcSpan toSourcePos sourcePosEltssrcLine dummySpan panicSpanatLoclocAtdummyLocdummyPos$fFixpointSourcePos$fHashableSourcePos$fPPrintSourcePos$fSerializeSourcePos$fBinarySourcePos$fNFDataSourcePos$fIsStringLocated$fHashableLocated$fBinaryLocated $fOrdLocated $fEqLocated$fPPrintLocated $fShowLocated$fTraversableLocated$fFoldableLocated$fFunctorLocated$fFixpointLocated$fNFDataLocated$fHashableSrcSpan$fPPrintSrcSpan$fSerializeSrcSpan$fLocSourcePos$fLoc() $fLocSrcSpan $fLocLocated $fDataLocated$fGenericLocated $fEqSrcSpan $fOrdSrcSpan $fShowSrcSpan $fDataSrcSpan$fGenericSrcSpanSymbolicsymbolLocText LocSymbolSymbol mappendSymisDummy symbolText symbolStringsymbolSafeTextsymbolSafeStringsymChars isPrefixOfSym isSuffixOfSymheadSymconsSym unconsSym lengthSymdropSym stripPrefix stripSuffix suffixSymbolvvisNontrivialVVvvCon dummySymbol testSymbol isTestSymbol litSymbol isLitSymbol unLitSymbol intSymbol tempSymbol renameSymbol kArgSymbol existSymbol gradIntSymbol tempPrefix anfPrefix tidySymbol nonSymbol isNonSymbolsymbolicString symbolBuilder buildMany lambdaName lamArgSymbolisLamArgSymbol setToIntNamebitVecToIntName mapToIntName realToIntName toIntName boolToIntName setApplyNamebitVecApplyName mapApplyName boolApplyName realApplyName intApplyName applyName coerceName preludeName dummyName boolConName funConName listConName listLConName tupConName setConName mapConNamevvName propConName strConName charConNamenilNameconsName size32Name size64Name bitVecNamebvOrName bvAndName mulFuncName divFuncNameisPrimprims$fFixpointText$fFixpointSymbol$fPPrintSymbol $fShowSymbol$fIsStringSymbol$fBinarySymbol$fNFDataSymbol$fHashableSymbol$fHashableDescription$fUninternableSymbol$fInternedSymbol $fOrdSymbol $fEqSymbol$fSymbolicSymbol $fSymbolic[]$fSymbolicText$fSymbolicLocated$fEqDescription $fDataSymbol$fGenericSymbol$fGenericInternedText$fDataInternedTextTCArgsWithArgsNoArgsTCEmbSubDataDeclDDeclddTyConddVarsddCtorsDataCtorDCtordcNamedcFields DataFieldDFielddfNamedfSortSortFIntFRealFNumFFracFObjFVarFFuncFAbsFTCFAppFTycon mappendFTC intFTyCon boolFTyCon realFTyCon numFTyCon strFTyCon listFTyCon setFTyCon mapFTyConisListTCsizeBv fTyconSymbolsymbolNumInfoFTyCon symbolFTyconfAppfAppTCfTyconSelfSortunFAppunAbsfObj sortFTycon functionSortsortAbsmapFVarmuSort isFirstOrder isNumericisRealisStringmkFFuncbkFFunc isPolyInstmkPolyboolSortcharSortstrSortintSortrealSortfuncSortsetSort bitVecSortmapSort fTyconSort basicSorts mkSortSubst sortSubst tceInsertWith tceInsert tceLookuptceMap tceFromList tceToList tceMember$fNFDataTCInfo$fBinaryTCInfo$fMonoidTCInfo$fSemigroupTCInfo$fNFDataFTycon$fBinaryFTycon$fPPrintFTycon$fFixpointFTycon $fLocFTycon$fHashableFTycon $fEqFTycon$fSymbolicFTycon $fMonoidSort$fSemigroupSort $fNFDataSort $fBinarySort$fFixpointSort$fHashableSort$fNFDataDataField$fBinaryDataField$fPPrintDataField$fFixpointDataField$fSymbolicDataField$fNFDataDataCtor$fBinaryDataCtor$fPPrintDataCtor$fFixpointDataCtor$fSymbolicDataCtor$fNFDataDataDecl$fBinaryDataDecl$fPPrintDataDecl$fFixpointDataDecl$fSymbolicDataDecl $fNFDataSub $fBinarySub$fPPrintTCArgs$fMonoidTCArgs$fSemigroupTCArgs$fNFDataTCArgs$fBinaryTCArgs $fMonoidTCEmb$fSemigroupTCEmb $fNFDataTCEmb $fEqTCInfo $fOrdTCInfo $fShowTCInfo $fDataTCInfo$fGenericTCInfo $fOrdFTycon $fShowFTycon $fDataFTycon$fGenericFTycon$fEqSort $fOrdSort $fShowSort $fDataSort $fGenericSort $fEqDataField$fOrdDataField$fShowDataField$fDataDataField$fGenericDataField $fEqDataCtor $fOrdDataCtor$fShowDataCtor$fDataDataCtor$fGenericDataCtor $fEqDataDecl $fOrdDataDecl$fShowDataDecl$fDataDataDecl$fGenericDataDecl $fGenericSub $fEqTCArgs $fOrdTCArgs $fShowTCArgs $fDataTCArgs$fGenericTCArgs $fEqTCEmb $fShowTCEmb $fDataTCEmb$fGenericTCEmbReftableisTautoppTytopbotmeettoReftofReftparamsSubablesymssubstasubstfsubstsubst1isFalse Predicateprop Expressionexpr SortedReftRRsr_sortsr_reftReftGradInfogsrcgusedExprESymEConEVarEAppENegEBinEIteECstELamETAppETAbsPAndPOrPNotPImpPIffPAtomPKVarPAllPExistPGradECoercBopPlusMinusTimesDivModRTimesRDivBrelEqNeGtGeLtLeUeqUneConstantIRLSymConstSLKVSubKVSksuVVksuSortksuKVarksuSubstSubstSuKVarKVkv HasGradual isGradualgVarsungradERDivEDivERTimesETimesEEqEBotPFalsePTopPTrue reftConjunctsintKvar srcGradInfomkEAppeApps splitEApp splitPAndeAppC debruijnIndexelit isContraPred isTautoPred pprintRefteVarePropisSingletonExprpAndpOr&.&|.|pItepExistmkPropisSingletonReftexprReft notExprReft uexprReftpropReftpredReftreft mapPredReftisFunctionSortedReft isNonTrivialreftPredreftBindpGAndspGAnd symbolReft usymbolReftvv_trueSortedRefttrueReft falseReft flattenRefas conjuncts $fPPrintTCEmb $fPPrintSort$fBinarySrcSpan $fBinaryTCEmb$fBinaryHashMap$fNFDataSrcSpan $fPPrintKVar$fFixpointKVar$fHashableKVar $fShowKVar $fBinaryKVar $fNFDataKVar$fPPrintSymConst$fFixpointSymConst$fSymbolicSymConst$fHashableSymConst$fBinarySymConst$fNFDataSymConst$fPPrintConstant$fFixpointConstant$fHashableConstant$fBinaryConstant$fNFDataConstant $fPPrintBrel$fFixpointBrel$fHashableBrel $fBinaryBrel $fNFDataBrel $fPPrintBop $fFixpointBop $fHashableBop $fBinaryBop $fNFDataBop$fHashableGradInfo$fBinaryGradInfo$fNFDataGradInfo $fPPrintExpr$fFixpointExpr $fPPrintSubst$fFixpointSubst $fShowSubst$fHashableExpr$fHashableSubst$fHasGradualExpr $fBinaryExpr $fBinarySubst $fNFDataExpr $fNFDataSubst $fPPrintKVSub$fHasGradualReft $fBinaryReft $fNFDataReft$fHasGradualSortedReft$fBinarySortedReft$fNFDataSortedReft$fExpressionLocated$fExpressionInt$fExpressionInteger$fExpressionText$fExpressionSymbol$fExpressionExpr$fExpressionReft$fExpressionSortedReft$fPredicateBool$fPredicateExpr$fPredicateSymbol$fFalseableReft$fFalseableExpr$fSubableLocated$fEqKVar $fOrdKVar $fDataKVar $fGenericKVar$fIsStringKVar $fEqSymConst $fOrdSymConst$fShowSymConst$fDataSymConst$fGenericSymConst $fEqConstant $fOrdConstant$fShowConstant$fDataConstant$fGenericConstant$fEqBrel $fOrdBrel $fShowBrel $fDataBrel $fGenericBrel$fEqBop$fOrdBop $fShowBop $fDataBop $fGenericBop $fEqGradInfo$fShowGradInfo$fDataGradInfo$fGenericGradInfo$fEqExpr $fShowExpr $fDataExpr $fGenericExpr $fEqSubst $fDataSubst$fGenericSubst $fEqKVSub $fDataKVSub$fGenericKVSub $fShowKVSub$fEqReft $fDataReft $fGenericReft$fEqSortedReft$fDataSortedReft$fGenericSortedReftTrigger NoTrigger LeftHandSide TriggeredTR noTriggerdefaultTrigger makeTriggers$fNFDataTrigger$fBinaryTrigger$fPPrintTrigger$fNFDataTriggered$fBinaryTriggered$fPPrintTriggered $fEqTrigger $fShowTrigger$fGenericTrigger $fEqTriggered$fShowTriggered$fFunctorTriggered$fGenericTriggeredfilterUnMatched TemplatesmatchesTemplates makeTemplatesisEmptyTemplatesisAnyTemplatesanything$fPPrintTemplates$fMonoidTemplates$fSemigroupTemplates$fHasTemplatesReft$fHasTemplatesExpr$fShowTemplates filterSubstmkSubst isEmptySubsttargetSubstSyms subst1Except substfExcept substExcept$fShowSortedReft $fShowReft$fFixpointSortedReft$fFixpointReft$fPPrintSortedReft $fPPrintReft$fReftableSortedReft$fReftableReft $fReftable()$fSubableSortedReft $fSubableReft$fMonoidSortedReft$fSemigroupSortedReft $fMonoidReft$fSemigroupReft $fMonoidExpr$fSemigroupExpr $fSubableExpr$fSubableSymbol$fSubableHashMap$fSubableMaybe $fSubable[] $fSubable(,) $fSubable() $fMonoidSubst$fSemigroupSubst FixResultCrashSafeUnsafeError1errLocerrMsgErrorerrscatError catErrorserrpanicdiedieAtexit resultDoc colorResult resultExiterrFreeVarInQualerrFreeVarInConstrainterrIllScopedKVar$fSerializeDoc$fSerializeTextDetails$fSerializeDoc0$fSerializeAnnotDetails$fFixpointError1$fPPrintError1 $fOrdError1$fSerializeError1$fExceptionError $fPPrintError$fSerializeError$fFunctorFixResult$fMonoidFixResult$fSemigroupFixResult $fEqFixResult$fNFDataFixResult$fExceptionFixResult$fBinaryFixResult$fSerializeFixResult $fEqError1 $fShowError1$fGenericError1 $fEqError $fOrdError $fShowError$fGenericError$fDataFixResult$fFoldableFixResult$fTraversableFixResult$fShowFixResult$fGenericFixResult$fGenericAnnotDetailsPackspackmSESearchFoundAltsEBindEnvBindEnvbeBindsSEnvIBindEnvBindMapBindIdsplitByQuantifiers toListSEnv fromListSEnv fromMapSEnvmapSEnvmapMSEnvmapSEnvWithKey deleteSEnv insertSEnv lookupSEnv emptySEnv memberSEnvintersectWithSEnvdifferenceSEnv filterSEnv unionSEnv unionSEnv'lookupSEnvWithDistance emptyIBindEnvdeleteIBindEnvmemberIBindEnvinsertsIBindEnv elemsIBindEnvfromListIBindEnv insertBindEnv emptyBindEnv filterBindEnvbindEnvFromList elemsBindEnv bindEnvToList mapBindEnvmapWithKeyMBindEnv lookupBindEnvfilterIBindEnv unionIBindEnvintersectionIBindEnv nullIBindEnv diffIBindEnv adjustBindEnvenvCsgetPackmakePack$fBinaryHashSet$fBinaryIBindEnv$fNFDataIBindEnv$fFixpointIBindEnv$fMonoidIBindEnv$fSemigroupIBindEnv$fPPrintIBindEnv $fBinarySEnv $fNFDataSEnv $fMonoidSEnv$fSemigroupSEnv $fShowSEnv$fFixpointSEnv $fFunctorSEnv $fPPrintSEnv$fPPrintSizedEnv$fBinarySizedEnv$fNFDataSizedEnv$fMonoidSizedEnv$fSemigroupSizedEnv$fFixpointSizedEnv$fFixpointEBindEnv $fMonoidPacks$fSemigroupPacks $fPPrintPacks$fFixpointPacks $fBinaryPacks $fNFDataPacks $fEqIBindEnv$fDataIBindEnv$fGenericIBindEnv$fEqSEnv $fDataSEnv $fGenericSEnv$fFoldableSEnv$fTraversableSEnv $fEqSizedEnv$fShowSizedEnv$fFunctorSizedEnv$fFoldableSizedEnv$fGenericSizedEnv$fTraversableSizedEnv $fEqPacks $fShowPacks$fGenericPacksSmtSortSIntSBoolSRealSStringSSetSMapSBitVecSVarSDataSemUninterpCtorTestFieldTheory TheorySymbolThytsSymtsRawtsSorttsInterpSymEnvseSortseTheoryseDataseLitsseApplsRawsymEnv symEnvTheory symEnvSort insertSymEnv insertsSymEnv symbolAtNamesymbolAtSmtName isIntSmtSort sortSmtSort $fBinarySem $fPPrintSem $fNFDataSem$fPPrintTheorySymbol$fFixpointTheorySymbol$fBinaryTheorySymbol$fNFDataTheorySymbol$fPPrintSmtSort$fBinarySmtSort$fNFDataSmtSort$fHashableSmtSort$fMonoidSymEnv$fSemigroupSymEnv$fBinarySymEnv$fNFDataSymEnv$fEqSem$fOrdSem $fShowSem $fDataSem $fGenericSem$fEqTheorySymbol$fOrdTheorySymbol$fShowTheorySymbol$fDataTheorySymbol$fGenericTheorySymbol $fEqSmtSort $fOrdSmtSort $fShowSmtSort $fDataSmtSort$fGenericSmtSort $fEqSymEnv $fShowSymEnv $fDataSymEnv$fGenericSymEnvRewriteSMeasuresmNamesmDCsmArgssmBodyEquationEqueqNameeqArgseqBodyeqSorteqRecAxiomEnvAEnvaenvEqs aenvSimpl aenvExpandSolverGInfoFIcmwsbsebindsgLitsdLitskutsqualsbindInfoddeclshoInfoassertsaeHOInfoHOIhoBindshoQualsSInfoFInfo FInfoWithOptsFIOfioFIfioOptsKutsKSksVars QualPatternPatNone PatPrefix PatSuffixPatExact QualParamQPqpSymqpPatqpSort QualifierQqNameqParamsqBodyqPos resStatus resSolution gresSolution FixSolution GFixSolutionTaggedCsenvsidstagsinfoclhscrhsSimpC_cenv_crhs_cidcbind_ctag_cinfoSubCslhssrhsSubcIdGWInfogsymgsortgexprginfoWfCGWfCwenvwrftwinfowexprwlocTaggwInfo updateWfCExprisGWfc strengthenHypstrengthenBindssubcId toGFixSolunsafesafeisSafeisUnsafewfCmkSubCsubCshiftVVaddIdstrueQual qualifiermkQ qualBinds remakeQualmkQual substVarssortVarsksMemberfi allowHOquals toFixpoint writeFInfo convertFormat saveQuery mkEquation $fFixpointDoc$fNFDataEliminate$fNFDataSMTSolver$fBinaryEliminate$fBinarySMTSolver $fNFDataWfC $fBinaryWfC $fFixpointWfC $fPPrintWfC $fShowWfC$fHasGradualWfC$fNFDataGWInfo$fBinaryGWInfo $fNFDataSubC $fBinarySubC $fPPrintSubC $fShowSubC$fFixpointFixResult $fNFDataSimpC $fBinarySimpC $fPPrintSimpC $fShowSimpC $fLocSimpC$fFixpointSimpC$fFixpointSubC$fTaggedCSubCa$fTaggedCSimpCa$fNFDataGFixSol$fBinaryGFixSol $fShowGFixSol$fPPrintGFixSol$fNFDataResult$fMonoidResult$fSemigroupResult$fPPrintQualPattern$fNFDataQualPattern$fBinaryQualPattern$fPPrintQualParam$fFixpointQualParam$fNFDataQualParam$fBinaryQualParam$fPPrintQualifier$fFixpointQualifier$fSubableQualifier$fLocQualifier$fNFDataQualifier$fBinaryQualifier $fMonoidKuts$fSemigroupKuts$fFixpointKuts $fNFDataKuts $fBinaryKuts$fMonoidHOInfo$fSemigroupHOInfo$fNFDataHOInfo$fBinaryHOInfo$fFixpointEquation$fPPrintEquation$fSubableEquation$fNFDataEquation$fBinaryEquation$fPPrintRewrite$fFixpointRewrite$fNFDataRewrite$fBinaryRewrite$fFixpointAxiomEnv$fPPrintAxiomEnv$fMonoidAxiomEnv$fSemigroupAxiomEnv$fNFDataAxiomEnv$fBinaryAxiomEnv $fMonoidGInfo$fSemigroupGInfo$fHasGradualGInfo $fNFDataGInfo $fBinaryGInfo $fPTableGInfo$fEqWfC $fGenericWfC $fFunctorWfC $fEqGWInfo$fGenericGWInfo$fEqSubC $fGenericSubC $fFunctorSubC$fGenericSimpC$fFunctorSimpC$fGenericGFixSol$fSemigroupGFixSol$fMonoidGFixSol$fFunctorGFixSol$fGenericResult $fShowResult$fFunctorResult$fEqQualPattern$fShowQualPattern$fDataQualPattern$fGenericQualPattern $fEqQualParam$fShowQualParam$fDataQualParam$fGenericQualParam $fEqQualifier$fShowQualifier$fDataQualifier$fGenericQualifier$fEqKuts $fShowKuts $fGenericKuts $fEqHOInfo $fShowHOInfo$fGenericHOInfo $fEqEquation$fShowEquation$fGenericEquation $fEqRewrite $fShowRewrite$fGenericRewrite $fEqAxiomEnv$fShowAxiomEnv$fGenericAxiomEnv $fEqGInfo $fShowGInfo$fFunctorGInfo$fGenericGInfo kvarDomain reftFreeVarssortedReftConcKVars SymConsts symConstsCoSub VisitablevisitVisitorctxExprtxExpraccExprdefaultVisitortransmapKVars mapKVars' mapGVars'mapExprmapMExpr mapKVarSubstssizelamSizeeappskvarsenvKVars envKVarsNrhsKVarsisKvarCisConcC stripCasts applyCoSubfoldSort foldDataDecl$fVisitableRewrite$fVisitableEquation$fVisitableAxiomEnv$fVisitableGInfo$fVisitableSubC$fVisitableSimpC$fVisitableSizedEnv$fVisitable(,)$fVisitableSortedReft$fVisitableReft$fVisitableExpr $fMonoidMInt$fSemigroupMInt$fSymConstsExpr$fSymConstsReft$fSymConstsSortedReft$fSymConstsSimpC$fSymConstsSubC$fSymConstsSizedEnv$fSymConstsGInfo wfcUniqifySMTLIB2smt2ContextCtxctxPidctxCinctxCoutctxLog ctxVerbose ctxSymEnvResponseSatUnsatUnknownValuesCommandPushPopCheckSatDeclDataDeclareDefineAssertAssertAxDistinctGetValueCManyrunSmt2$fPPrintCommand $fEqCommand $fShowCommand $fEqResponse$fShowResponsesetEmptysetEmpsetCapsetSubsetAddsetMemsetComsetCupsetDifsetSngmapSelmapStomapCupmapDef smt2Symbolsmt2App isSmt2Apppreamble theorySymbols maxLamArg axiomLiteralsdataDeclSymbols$fSMTLIB2SmtSortBvOpBvAndBvOrBvSizeS32S64BvmkSortbvTyConeOp$fExpressionBv $fEqBvSize $fOrdBvSize $fShowBvSize $fDataBvSize$fGenericBvSize$fEqBvOp $fOrdBvOp $fShowBvOp $fDataBvOp $fGenericBvOpTVSubstEnv Elaborate elaborateisMonosortExpr checkSortExpr mkSearchEnvcheckSortedReftcheckSortedReftFull checkSortFull checkSortedpruneUnsortedRefttoInt unApplyAt applySortsexprSortexprSort_maybeunifyTo1 unifySorts unifyFastapply$fElaborateSimpC$fElaborateSizedEnv$fElaborateSortedReft $fElaborate[]$fElaborate(,)$fElaborateExpr$fElaborateEquation$fElaborateRewrite$fElaborateAxiomEnv$fElaborateSort$fElaborateMaybe$fElaborateTriggered$fElaborateGInfo$fCheckableSortedReft$fCheckableExpr$fMonoidTVSubst$fSemigroupTVSubst $fShowTVSubstCMapIndexFastIdxbindExprkvUsekvDefenvBindsenvTxenvSortsBindPredBPbpConcbpKVarBIndexRootCstrKIndexkiBIndexkiPoskiKVarEQualEQLeqQualeqPred_eqArgsCandCubecuBindscuSubstcuIdcuTagHypSolsEnvgMapsScpsEbdsxEnvEbindSolEbDefEbSolEbIncrGBindQBind GSolutionSolutionupdate emptyGMapupdateGMapWithKeyqbqbExprsqbToGbgbToQbsgbEqualsequalsGb gbFilterMqbFilter updateEbind updateGMapresult resultGradualqbPreds lookupQBindglookuplookup trueEqualeQual$fPPrintEbindSol $fShowCube $fPPrintCube $fPPrintSol $fFunctorSol $fMonoidSol$fSemigroupSol $fNFDataEQual $fPPrintEQual $fLocEQual $fNFDataGBind $fPPrintQBind $fNFDataQBind$fPPrintKIndex$fHashableKIndex$fPPrintBIndex$fHashableBIndex$fPPrintBindPred$fShowEbindSol$fGenericEbindSol$fNFDataEbindSol $fGenericCube $fNFDataCube $fGenericSol $fEqEQual $fShowEQual $fDataEQual$fGenericEQual $fShowGBind $fDataGBind$fGenericGBind $fShowQBind $fDataQBind$fGenericQBind $fEqQBind $fEqKIndex $fOrdKIndex $fShowKIndex$fGenericKIndex $fEqBIndex $fOrdBIndex $fShowBIndex$fGenericBIndex$fShowBindPred $fNFDataSol nontrivsorts $fHashableNTV$fEqNTV$fOrdNTV $fShowNTV $fGenericNTV smt2SortMono$fSMTLIB2Triggered$fSMTLIB2Command $fSMTLIB2Expr $fSMTLIB2Brel $fSMTLIB2Bop$fSMTLIB2Constant$fSMTLIB2SymConst$fSMTLIB2Located$fSMTLIB2Symbol $fSMTLIB2(,)checkValidWithContext checkValid checkValid' checkValidscommandsmtWrite makeContextmakeContextWithSEnvmakeContextNoLogcleanupContextsmtPushsmtPopsmtDeclssmtDecl smtFuncDecl smtCheckSat smtAssertsmtAssertAxiom smtDistinct smtCheckUnsat smtBracketAt smtBracket Inputablerrrr'FixityFInfixFPrefixFPostfixfpredfnamefop2fassocfop1PState fixityTableempListsingListParserlexerreserved reservedOpangles stringLiteral whiteSpaceblanks locParserPcondIdPupperIdPlowerIdP isNotReservedinfixIdPisSmall locLowerIdP locUpperIdPsymbolP constantPexpr0PexprP addOperatorPfunAppPsortPbvSortPpredPrefaPrefBindPbindPrefPrefDefP dataFieldP dataCtorP dataDeclP qualifierPpairP remainderP initPStatedoParse' parseFromFile freshIntP $fInputable[]$fInputableCommand$fInputableFInfoWithOpts$fInputableGInfo$fInputable(,)$fInputableFixResult$fInputableExpr$fInputableConstant$fInputableSymbol $fShowDef $fGenericDef isReducibleQueryqQualsqVarsqCstrqConqDisHeadCAndAnybSymbSortbPredVarHVarhvNamehvArgshvMeta dummyBindcLabelokCstr $fPPrintVar $fShowVar $fPPrintPred $fShowPred $fMonoidPred$fSemigroupPred $fPPrintBind $fShowBind $fPPrintCstr $fShowCstr$fEqVar$fOrdVar $fDataVar $fGenericVar $fFunctorVar $fDataPred $fGenericPred$fEqPred $fDataBind $fGenericBind$fEqBind $fDataCstr $fGenericCstr $fFunctorCstr$fEqCstr $fDataQuery$fGenericQuery$fFunctorQueryhornP$fFunctorHThing hornFInfo$fGenericKVInfo$fFunctorKVInfo SolverInfoSIsiSolsiQuerysiDepssiVarsRankrSccrIccrTagCDepsCDscSucccPrevcRankcNumSccCGraphgEdgesgRanksgSuccgSccsSliceslKVarCsslConcCsslEdgesDepEdgeKVReadKVCompsCompsCEdgeKVGraphkvgEdgesCVertexDKVarEBind writeGraph writeEdges isRealEdge lookupCMap$fHashableCVertex$fPPrintCVertex$fPPrintKVGraph $fPPrintRank $fEqCVertex $fOrdCVertex $fShowCVertex$fGenericCVertex $fEqSlice $fShowSlice$fEqRank $fShowRankIKVGraphigSuccigPredaddLinksdelNodes edgesIkvg ikvgEdgesgetSuccsgetPreds$fShowIKVGraphElimsDepsdepCuts depNonCutssliceisTarget decomposekvEdgeselimDepselimVarsgraphStatistics $fMonoidElims$fSemigroupElims $fPPrintElims $fPTableStats $fShowElimsMCInfomcCores mcMinPartSize mcMaxPartSizeCPartpwspcmmcInfo partition partition' partitionNdumpPartitions $fMonoidCPart$fSemigroupCPart $fShowMCInfo statistics $fPPrintStats $fNFDataStats $fShowStats$fGenericStatsStatsWorklistwRanksinitunsatCandidatespoppush $fOrdWorkItem$fPPrintWorkItem$fPTableWorklist$fPPrintWorklist $fEqStats $fEqWorkItem$fShowWorkItemsanitizedropDeadSubsts symbolEnvGradualgsubstGSol makeSolutionsuniquify $fShowGSol $fMonoidGSol$fSemigroupGSol $fUniqueExpr $fUniqueReft$fUniqueSortedReft $fUniqueInt$fUniqueIBindEnv $fUniqueSimpC$fUniqueHashMap$fGradualGInfo$fGradualHashMap$fGradualSizedEnv$fGradualSimpC$fGradualSortedReft $fGradualReft $fGradualExpr renameAll $fHashableRef $fNFDataRef$fEqRef $fGenericReflhsPred$fLocCombinedEnv $fMonoidKInfo$fSemigroupKInfo $fEqKInfo $fOrdKInfo $fShowKInfonumIterSolveM runSolverMgetBindsfilterRequired filterValidfilterValidGradual smtEnablembqicheckSattickIterDefuncdefuncdefunctionalize defuncAny$fDefuncHashMap $fDefunc[] $fDefuncSort$fDefuncSizedEnv $fDefuncSEnv $fDefuncExpr $fDefuncReft $fDefunc(,) $fDefunc(,)0$fDefuncSortedReft $fDefuncWfC $fDefuncSimpC$fDefuncTriggered $fDefuncGInfo instantiate$fExpression(,) $fPPrintTrie $fPPrintRecur $fEqRecur $fShowRecur solverInfosolveminQueryminQualsminKvarssolveFQresultExitCode simplifyFInfo parseFInfoflattensolveEbselimPis cstrToExpruniqelim$fVisitableCstr$fVisitablePred $fSubablePred $fSubableBind $fFlatten[] $fFlattenExpr $fFlatten[]0 $fFlattenPred $fFlatten[]1 $fFlattenCstr solveHorn _example0version getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamebaseGHC.Base<>SafeText$ textSymbol alphaChars FalseableparensIf exprSymbols wiredInEnv funcSortsghc-prim GHC.TypesInt newTopBindeltsetmapselfSortfldSorttheorifyCheckMelabExpr elabApply checkExprelab defuncEAppBoolcheckSymcheckItecheckCst checkApp'checkNeg checkPredcheckRel unifyExprunify checkFunSort errElabExprsMapsHyp NonTrivSorts padDataDeclsmt2CastsymKinddistinctLiteralsorderDeclarationsDefexpr1PlitPpred0PdefineP fixResultPHThing hQualifierPhVarPsymSortPKVEnvgoS stNumKVCuts stNumKVNonLin stNumKVTotal stIsReducible stSetKVNonLincGraph graphRankskvSucc graphElimsccElims boundElims PartitionCtor cpartSize cpartToFinfo finfoToCpartpartitionByConstraintswiCIdwiTimewiRankWorkSetaddPendssAddsKvDom safeKvarEnv_dropAdtMeasures addLiterals_banIllScopedKvarsrestrictKVarDomain restrictWfbanConstraintFreeVarsbanQualifFreeVars banMixedRhsdropFuncSortedShadowedBinders sanitizeWfC _nonDerivedLH dropBindersreplaceDeadKvarsUniqueMexpandWF RenameMap GHC.MaybeNothingIdMapRBRIdropUnusedBinds renameVarsKInfo elabExist cubePredExc substElim ebindInfonumCstrnumBrktnumChcknumValdssCtxssBindsssStatsdfHOdfLamsdfRedexdfBindsfreshSym KnowledgeknSimsassertSelectorsknAmsRecurevalUnfoldInstResICtxicAssmsicCandsicEqualsicSolvedInstEnvincrInstantiate'instEnvmkCTriepleTrieple1resSInfoupdCtx instantiate'evaluateevalArgsidevalOksubstEqinitEqualitiesDiffwithProgressFI tidyResultrefineCminimizeResultrhsPred_iMergePartitions solveSeqWith solveParWithinParallelUsing solveNative solveNative'Flatten Data.Foldableand piDefConstrpokecsplitdefselimKs'rewriteWithEqualitiesscopesol1doelim _boundVarsisNNF