fact stringlengths 6 30.1k | type stringclasses 2
values | library stringclasses 46
values | imports listlengths 0 156 | filename stringlengths 12 117 | symbolic_name stringlengths 1 145 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
setup-env (processed-var-specs env ctx) : (loop for (name . ty) in processed-var-specs when (multiple-value-bind (existing-ty exists?) (env-get name env) (cond ((not exists?) (env-set name (cons ty (convert-type-spec name ty ctx)) env) name) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | setup-env | |
declare-const-fn (name sort &optional solver) : (let* ((slv (or solver *default-solver*)) (ctx (get-context slv)) (new-vars (setup-env `((,name . ,sort)) (solver-env slv) ctx))) (unless new-vars (warn "Variable ~a was already declared with sort ~a." name (env-get name (solver-env slv)))) name)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | declare-const-fn | |
declare-fun-fn (name param-sorts res-sort &optional solver) : (let ((slv (or solver *default-solver*))) (if (endp param-sorts) (declare-const-fn name res-sort slv) (let* ((ctx (get-context slv)) (new-vars (setup-env `((,name . (:fn ,param-sorts ,res-sort))) (solver-env slv) ctx))) (unless new-vars (warn "Variable ~a wa... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | declare-fun-fn | |
z3-assert-fn (var-specs stmt &optional solver) : (let* ((slv (or solver *default-solver*)) (ctx (get-context slv)) (processed-var-specs (process-var-specs var-specs)) (added-vars (setup-env processed-var-specs (solver-env slv) ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | z3-assert-fn | |
z3-assert-soft-fn (var-specs stmt weight &optional solver) : (let* ((slv (or solver *default-solver*)) (ctx (get-context slv)) (processed-var-specs (process-var-specs var-specs)) (added-vars (setup-env processed-var-specs (solver-env slv) ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | z3-assert-soft-fn | |
z3-optimize-minimize-fn (var-specs stmt &optional solver) : (let* ((slv (or solver *default-solver*)) (ctx (get-context slv)) (processed-var-specs (process-var-specs var-specs)) (added-vars (setup-env processed-var-specs (solver-env slv) ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | z3-optimize-minimize-fn | |
z3-optimize-maximize-fn (var-specs stmt &optional solver) : (let* ((slv (or solver *default-solver*)) (ctx (get-context slv)) (processed-var-specs (process-var-specs var-specs)) (added-vars (setup-env processed-var-specs (solver-env slv) ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | z3-optimize-maximize-fn | |
get-model (&optional solver) : "Get the Z3 model object for the last `check-sat` call. If that call indicated that Z3 determined satisfiability, then the model will contain a satisfying assignment for the assertions in the global assertion stack. If `check-sat` determined `:UNKNOWN` then a model may be available, but t... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | get-model | |
get-model-as-assignment (&optional solver) : "If Z3 has determined that the global assertion stack is satisfiable, get a satisfying assignment. Returns a (possibly empty) list of bindings corresponding to the model that Z3 generated. Will invoke the error handler if no model is available. If check-sat determined `:UNKN... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | get-model-as-assignment | |
check-sat (&optional solver) : "Ask Z3 to check satisfiability of the global assertion stack. Returns either `:SAT`, `:UNSAT` or `:UNKNOWN`." (let ((slv (or solver *default-solver*))) (match (solver-check slv) (:L_TRUE :SAT) ;; assertions are satisfiable (a model may be generated) (:L_FALSE :UNSAT) ;; assertions are no... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | check-sat | |
eval-under-model-fn (stmt model solver completion) : (let* ((ctx (get-context solver)) (ast (convert-to-ast stmt (solver-env solver) ctx))) (cffi:with-foreign-object (res-ptr 'z3-c-types::Z3_ast) (let ((success? (z3-model-eval ctx model ast completion res-ptr))) (if success? (ast-to-value (make-instance 'ast :handle (c... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/api.lisp | eval-under-model-fn | |
list-to-ast-vector (list ctx) : (let ((vec (z3-mk-ast-vector ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast-vector.lisp | list-to-ast-vector | |
make-fn-call (name args ctx env) : (multiple-value-bind (fn-entry exists?) (env-get name env) (unless (and exists? (consp (car fn-entry)) (equal (caar fn-entry) :fn)) (error "No function with name ~S is known" name)) (let* ((decl (cdr fn-entry)) (arg-sorts-debug (second (car fn-entry)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | make-fn-call | |
convert-to-ast-fn (context stmt env) : (match stmt ((or t (sym-name true)) (z3-mk-true context)) ((or nil (sym-name false)) (z3-mk-false context)) ((satisfies integerp) (z3-mk-numeral context (write-to-string stmt) (z3-mk-int-sort context))) ((type symbol) (multiple-value-bind (ty-entry exists?) (env-get stmt env) (if ... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | convert-to-ast-fn | |
process-bound-vars (bound-vars context env) : (let ((new-env (env-flat-copy env)) (processed-var-specs (process-var-specs bound-vars))) (check-processed-var-specs processed-var-specs) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | process-bound-vars | |
mk-quantifier (is-forall bound-vars body context env) : | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | mk-quantifier | |
mk-set (sort values ctx env) : (if (endp values) (z3-mk-empty-set ctx sort) (z3-mk-set-add ctx (mk-set sort (cdr values) ctx env) (convert-to-ast-fn ctx (car values) env)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | mk-set | |
convert-to-ast (stmt &optional (env (make-instance 'environment-stack) : ) context) "Convert a Common Lisp S-expression into a Z3 AST, with respect to the given environment." (let ((ctx (or context *default-context*))) (make-instance 'ast :handle (convert-to-ast-fn ctx stmt env) :context ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | convert-to-ast | |
get-key (k l) : (cadr (member k l :test #'equal))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | get-key | |
convert-as-to-ast (context stmt sort-spec env) : (match stmt ((sym-name seq.empty) (unless (and (consp sort-spec) (sort-names-match? (car sort-spec) :seq)) (error "You must provide a sequence sort when using (as seq.empty <sort>)")) (z3-mk-seq-empty context (get-sort sort-spec context))) ((sym-name set.empty) (unless (... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | convert-as-to-ast | |
convert-funccall-to-ast (context stmt env) : (match stmt ((list (sym-name !=) x y) (convert-funccall-to-ast context `(not (equal ,x ,y)) env)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | convert-funccall-to-ast | |
app-ast-args-to-list (ast ctx) : "Get the arguments of an application AST as a list of Z3 AST values." (assert (equal (z3-get-ast-kind ctx ast) :app_ast)) (loop for i below (z3-get-app-num-args ctx ast) collect (z3-get-app-arg ctx ast i))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | app-ast-args-to-list | |
seq-ast-to-value (ast ctx) : "Translate a sequence AST into a Lisp list value" (assert (equal (z3-get-ast-kind ctx ast) :app_ast)) (assert (equal (z3-get-sort-kind ctx (z3-get-sort ctx ast)) :seq_sort)) (let* ((decl (z3-get-app-decl ctx ast)) (decl-kind (z3-get-decl-kind ctx decl))) (match decl-kind (:OP_SEQ_EMPTY nil)... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | seq-ast-to-value | |
array-ast-to-value (ast ctx) : "Translate an array AST into a Lisp alist value" (assert (equal (z3-get-ast-kind ctx ast) :app_ast)) (assert (equal (z3-get-sort-kind ctx (z3-get-sort ctx ast)) :array_sort)) (let* ((decl (z3-get-app-decl ctx ast)) (decl-kind (z3-get-decl-kind ctx decl))) (match decl-kind (:OP_STORE (cons... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | array-ast-to-value | |
get-lstring (context ast) : (assert (z3-is-string context ast)) (cffi:with-foreign-object (size-ptr :uint 1) (let* ((str-ptr (z3-get-lstring context ast size-ptr)) (size (cffi:mem-ref size-ptr :uint)) (res-vec (make-array (list size) :element-type '(unsigned-byte 8)))) (loop for i below size do (setf (aref res-vec i) (... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | get-lstring | |
algebraic-number-to-value (val) : (ecase *ALGEBRAIC-NUMBER-CONVERT-MODE* (:float (algebraic-number-to-float val)) (:decimal (with-slots (handle context) val (z3-get-numeral-decimal-string context handle *ALGEBRAIC-NUMBER-CONVERT-DECIMAL-PRECISION*))) (:root (with-slots (handle context) val (z3-ast-to-string context han... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | algebraic-number-to-value | |
assert-app-decl-kind (ctx ast kind) : (assert (equal (z3-get-ast-kind ctx ast) :app_ast)) (let* ((decl (z3-get-app-decl ctx (z3-to-app ctx ast))) (decl-kind (z3-get-decl-kind ctx decl))) (assert (equal decl-kind kind)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | assert-app-decl-kind | |
app-ast-to-value (ast ctx) : (assert (equal (z3-get-ast-kind ctx ast) :app_ast)) (let* ((decl (z3-get-app-decl ctx (z3-to-app ctx ast)))) (match (z3-get-decl-kind ctx decl) (:OP_TRUE t) (:OP_FALSE nil) (:OP_DT_CONSTRUCTOR (let* ((sort (z3-get-sort ctx ast))) (cond ((enum-sort? sort ctx) (get-enum-value sort decl ctx)) ... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | app-ast-to-value | |
ast-to-value (ast ctx) : "Attempt to translate a Z3 AST into a Lisp value." (let* ((ast-kind (z3-get-ast-kind ctx ast)) (sort (z3-get-sort ctx ast)) (sort-kind (z3-get-sort-kind ctx sort))) (match ast-kind (:app_ast (app-ast-to-value ast ctx)) (:numeral_ast (match sort-kind ((or :int_sort :finite_domain_sort :bv_sort) ... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | ast-to-value | |
parse-smt2-string (filename &key sorts decls context) : "Parse the given string using the SMT-LIB2 parser. It returns an ast-vector comprising of the conjunction of assertions in the scope (up to push/pop) at the end of the string." (let ((ctx (or context *default-context*))) (make-instance 'ast-vector :handle (with-fo... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | parse-smt2-string | |
parse-smt2-file (filename &key sorts decls context) : "Parse the file with the given filename using the SMT-LIB2 parser. It returns an ast-vector comprising of the conjunction of assertions in the scope (up to push/pop) at the end of the file. Calls the error handler if the file does not exist or cannot be accessed." (... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/ast.lisp | parse-smt2-file | |
make-config () : (make-instance 'config)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | make-config | |
del-config (config) : (z3-c::z3-del-config config)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | del-config | |
set-config-param (config id value) : (z3-c::z3-set-param-value config id value)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | set-config-param | |
reset-global-params () : (z3-c::z3-global-param-reset-all)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | reset-global-params | |
set-global-param (id value) : "Set the global parameter with the given id to the given value. Prints a warning if no such parameter exists or if the value is of an incorrect type." (z3-c::z3-global-param-set id value)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | set-global-param | |
get-global-param (id) : "Get a string representing the current value of the global parameter with the given id. Returns nil and prints a warning if no such parameter exists." (with-foreign-pointer (retval 1) (z3-c::z3-global-param-get id retval) (values (foreign-string-to-lisp (mem-ref retval :pointer))))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/config.lisp | get-global-param | |
func-decl-domain (decl context) : "Get the domain of the function declaration, as a list of sorts." (loop for i below (z3-get-domain-size context decl) collect (make-instance 'z3-sort :handle (z3-get-domain context decl i) :context context))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/func-decl.lisp | func-decl-domain | |
func-decl-range (decl context) : "Get the range of the function declaration, as a sort." (make-instance 'z3-sort :handle (z3-get-range context decl) :context context)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/func-decl.lisp | func-decl-range | |
set-solver (solver) : (setf *default-solver* solver)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/globals.lisp | set-solver | |
func-entry-to-string (entry context) : (let ((s (make-string-output-stream))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/model.lisp | func-entry-to-string | |
model-constants (model) : "Retrieve constant interpretations from the given model." | function | workshops | [] | workshops/2025/walter-manolios/src/z3/model.lisp | model-constants | |
convert-func-entry (entry ctx) : "Convert a function interpretation entry into a cons pair." (z3-func-entry-inc-ref ctx entry) (let ((args (loop for i below (z3-func-entry-get-num-args ctx entry) collect (ast-to-value (z3-func-entry-get-arg ctx entry i) ctx))) (val (ast-to-value (z3-func-entry-get-value ctx entry) ctx)... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/model.lisp | convert-func-entry | |
func-interp-to-alist (interp ctx) : "Translate a function intepretation into an alist." (let ((num-entries (z3-func-interp-get-num-entries ctx interp))) (cons (cons :default (ast-to-value (z3-func-interp-get-else ctx interp) ctx)) (loop for i below num-entries for entry = (z3-func-interp-get-entry ctx interp i) collect... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/model.lisp | func-interp-to-alist | |
model-functions (model) : "Retrieve function interpretations from the given model." | function | workshops | [] | workshops/2025/walter-manolios/src/z3/model.lisp | model-functions | |
guess-param-type (value) : (match value ((type boolean) :bool) ((satisfies integerp) :uint) ((type real) :double) ((or (type string) (type symbol)) :symbol) (otherwise (error "Unable to guess the type of the parameter value ~S. Try providing an explicit type for it." value)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/params.lisp | guess-param-type | |
params-set (params name value context &optional ty) : (let ((ty (if ty ty (guess-param-type value))) (name-sym (z3-mk-string-symbol context name))) (match ty (:bool (assert (typep value 'boolean)) (z3-params-set-bool context params name-sym value)) (:uint (assert (or (zerop value) (plusp value))) (z3-params-set-uint co... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/params.lisp | params-set | |
make-params-fn (settings context) : (let ((params (make-instance 'params :handle (z3-mk-params context) :context context))) (z3-params-inc-ref context params) (loop for setting in settings do (let* ((name (string-downcase (symbol-name (car setting)))) (value (second setting)) (ty (third setting))) (params-set params na... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/params.lisp | make-params-fn | |
make-simple-solver (&optional context) : "Create a new incremental solver that will not apply any logic-specific tactics or change its behavior based on whether it is used incrementally or not. See `z3-mk-simple-solver` for more information." (let ((ctx (or context (make-instance 'context)))) (make-instance 'solver :ha... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | make-simple-solver | |
make-composite-solver (&optional context) : "Create a new solver that internally consists of both a non-incremental and an incremental solver. Which solver is used depends on whether the composite solver is used in a incremental way (e.g. `solver-push` or `solver-pop` are used, or the set of assertions is modified afte... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | make-composite-solver | |
make-solver-for-logic (logic &optional context) : "Create a new solver that is optimized for the logic with the given name. Note that this will fail silently if the given logic isn't known by Z3, creating the same solver as `make-simple-solver` in that case. See `z3-mk-solver-for-logic` for more information." (let ((ct... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | make-solver-for-logic | |
make-solver-from-tactic (tactic &optional context) : "Create a new solver that will operate using the given tactic. The solver will not be incremental. See `z3-mk-solver-from-tactic` for more information." (let ((ctx (or context *default-context*))) (make-instance 'solver :handle (z3-mk-solver-from-tactic ctx tactic) :... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | make-solver-from-tactic | |
make-optimizer (&optional context) : "Create a solver that is capable of performing optimization." (let ((ctx (or context (make-instance 'context)))) (make-instance 'optimizer :handle (z3-mk-optimize ctx) :context ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | make-optimizer | |
get-solver-help (&optional solver) : (let ((slv (or solver *default-solver*))) (z3-solver-get-help (get-context slv) slv))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | get-solver-help | |
get-solver-param-descrs (&optional solver) : (let ((slv (or solver *default-solver*))) (make-instance 'param-descrs :handle (z3-solver-get-param-descrs (get-context slv) slv) :context (get-context slv)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | get-solver-param-descrs | |
get-solver-stats (&optional solver) : "Get statistics from the given solver." (get-solver-stats-fn (or solver *default-solver*))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | get-solver-stats | |
set-params-fn (params solver) : (let* ((ctx (get-context solver)) (param-descrs (get-solver-param-descrs solver))) (z3-params-validate ctx params param-descrs) (when (equal (z3-get-error-code ctx) :OK) (z3-solver-set-params ctx solver params)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/solver.lisp | set-params-fn | |
normalize-sort-name (name) : (intern (symbol-name name) :z3-sort)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | normalize-sort-name | |
register-sort (name sort-producer) : "Register a sort. The first argument is either a symbol or a list of symbols. If a single symbol, the name of the sort to register. If a list of symbols, this sort will be registered under each symbol. The second argument should be a function object that takes in a single argument (... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | register-sort | |
register-parametric-sort (name parametric-sort-producer) : "Register a sort. The first argument is either a symbol or a list of symbols. If a single symbol, the name of the parametric sort to register. If a list of symbols, this parameteric sort will be registered under each symbol. The second argument should be a func... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | register-parametric-sort | |
register-indexed-sort (name indexed-sort-producer) : "Register a sort. The first argument is either a symbol or a list of symbols. If a single symbol, the name of the indexed sort to register. If a list of symbols, this indexed sort will be registered under each symbol. The second argument should be a function object t... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | register-indexed-sort | |
get-sort (name context) : "Get the sort associated with the given name." (match name ((type symbol) (multiple-value-bind (fn exists?) (gethash (normalize-sort-name name) *sorts*) (if exists? (funcall fn context) (error "No known sort with name ~a" name)))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | get-sort | |
register-enum-sort-fn (name elements ctx) : "Register an enum sort with the given name and elements in the given context." (cffi:with-foreign-objects ((elt-names 'z3-c-types::Z3_symbol (length elements)) ;; input (consts 'z3-c-types::Z3_func_decl (length elements)) ;; output (testers 'z3-c-types::Z3_func_decl (length e... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | register-enum-sort-fn | |
sort-name (sort context) : "Get the name of a sort." (z3-get-symbol-string context (z3-get-sort-name context sort))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | sort-name | |
enum-value-func-def (name value) : "Get the constant func-def corresponding to the given enum sort element." (multiple-value-bind (metadata exists?) (gethash (normalize-sort-name name) *enum-sort-metadata*) (cond ((not exists?) (error "~S does not name an enum sort." name)) ((not (member value (enum-sort-metadata-names... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | enum-value-func-def | |
enum-value-to-ast (name value ctx) : "Get an AST node corresponding to the given enum sort element." (z3-mk-app ctx (enum-value-func-def name value) 0 (cffi:null-pointer))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | enum-value-to-ast | |
enum-tester-func-def (name value) : "Get the tester func-def for the given enum sort element." (multiple-value-bind (metadata exists?) (gethash (normalize-sort-name name) *enum-sort-metadata*) (cond ((not exists?) (error "~a does not name an enum sort." name)) ((not (member value (enum-sort-metadata-names metadata))) (... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | enum-tester-func-def | |
get-enum-value (sort decl context) : "Given a func-decl corresponding to an element of an enum sort, return the Lisp equivalent of the enum element." | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | get-enum-value | |
register-tuple-sort-fn (name fields ctx) : "Register a tuple sort with the given name and fields in the given context." | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | register-tuple-sort-fn | |
get-tuple-fields (sort app context) : "Given a application corresponding to the construction of a tuple value, return the AST values of the fields of the tuple." (let* ((sort-name (intern (sort-name sort context) :z3-sort))) (multiple-value-bind (metadata exists?) (gethash sort-name *tuple-sort-metadata*) (cond ((not e... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | get-tuple-fields | |
construct-tuple-fn (tuple-name values context) : "Make an AST node that constructs a value of the given tuple with the given field values. Field values must be provided in the same order as they were defined in the register-tuple-sort call for this tuple sort." | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | construct-tuple-fn | |
get-tuple-field-accessor-decl-fn (tuple-name field-name context) : (declare (ignore context)) (multiple-value-bind (metadata exists?) (gethash (normalize-sort-name tuple-name) *tuple-sort-metadata*) (cond ((not exists?) (error "~a does not name a tuple sort." tuple-name)) ((not (member field-name (tuple-sort-metadata-f... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | get-tuple-field-accessor-decl-fn | |
construct-tuple-field-accessor-fn (tuple-name field-name tuple-value context) : "Make an AST node that accesses the given field of the given tuple-value." (with-foreign-array (args-array z3-c-types::Z3_ast (list tuple-value)) (z3-mk-app context (get-tuple-field-accessor-decl-fn tuple-name field-name context) 1 args-arr... | function | workshops | [] | workshops/2025/walter-manolios/src/z3/sorts.lisp | construct-tuple-field-accessor-fn | |
make-tactic (name &optional context) : "Make an instance of the tactic with the given name. Will signal an error if the name is incorrect." (let ((ctx (or context *default-context*))) (make-instance 'tactic :handle (z3-mk-tactic ctx name) :context ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/tactic.lisp | make-tactic | |
make-tactic-with-params (tac params &optional context) : (let ((ctx (or context *default-context*))) (make-instance 'tactic :handle (z3-tactic-using-params ctx tac params) :context ctx))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/tactic.lisp | make-tactic-with-params | |
make-algebraic-number (context handle) : (make-instance 'algebraic-number :context context :handle handle)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/types.lisp | make-algebraic-number | |
foreign-array-to-list (arr ty len) : "Convert a foreign array of the given element type and length into a list." (loop for i below len collect (cffi:mem-aref arr ty i))) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/util.lisp | foreign-array-to-list | |
fresh-env-from-spec-fn (var-specs context) : (let* ((ctx (or context *default-context*)) (env (make-instance 'environment-stack)) (processed-specs (process-var-specs var-specs))) (check-processed-var-specs processed-specs) (setup-env processed-specs env ctx) env)) | function | workshops | [] | workshops/2025/walter-manolios/src/z3/util.lisp | fresh-env-from-spec-fn | |
natp-of-foo3 : (implies (natp x) (natp (foo3 x)))) (local (defthm foo3-lemma (implies (equal x 3) (equal (foo3 x) 4)))) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | natp-of-foo3 | |
posp-of-foo3 : (implies (natp x) (posp (foo3 x)))) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | posp-of-foo3 | |
oddp-of-foo3 : (implies (evenp x) (oddp (foo3 x))))) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | oddp-of-foo3 | |
integerp-of-foo3 : (implies (integerp x) (integerp (foo3 x))))) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | integerp-of-foo3 | |
det-f1-identity : (equal (det-f1 x) x)) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f1-identity | |
det-f2-identity : (equal (det-f2 x) x)) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f2-identity | |
det-f3-identity : (equal (det-f3 x) x)) (assert! (b* ((topic (find-topic 'double-extension-test (get-xdoc-table (w state)))) (long (cdr (assoc :long topic)))) (and (str::substrp "@(def? |XDOC|::|DET-F1|)" long) (str::substrp "@(def? |XDOC|::|DET-F2|)" long) (str::substrp "@(def? |XDOC|::|DET-F3|)" long) (str::substrp "... | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f3-identity | |
det2-f1-identity : (equal (det2-f1 x) x)) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f1-identity | |
det2-f2-identity : (equal (det2-f2 x) x)) | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f2-identity | |
det2-f3-identity : (equal (det2-f3 x) x)) (assert! (b* ((topic (find-topic 'double-extension-test2 (get-xdoc-table (w state)))) (long (cdr (assoc :long topic)))) (and (str::substrp "@(def? |XDOC|::|DET2-F1|)" long) (str::substrp "@(def? |XDOC|::|DET2-F2|)" long) (str::substrp "@(def? |XDOC|::|DET2-F3|)" long) (str::sub... | theorem | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f3-identity | |
foo1 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | foo1 | |
foo2 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | foo2 | |
det-f1 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f1 | |
det-f2 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f2 | |
det-f3 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det-f3 | |
det2-f1 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f1 | |
det2-f2 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f2 | |
det2-f3 (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | det2-f3 | |
oops (x) : x)) | function | xdoc | [
"../top",
"std/util/bstar",
"std/strings/substrp",
"std/testing/assert-bang"
] | xdoc/tests/defsection-tests.lisp | oops | |
f (x) : (er hard? 'f "X is ~x0." x)) (test-fail (f 3)) | function | xdoc | [
"../unsound-eval",
"centaur/vl/util/print",
"std/util/defconsts"
] | xdoc/tests/unsound-eval-tests.lisp | f | |
infinite (x) : (declare (xargs :mode :program)) (if (zp x) nil (cons 1 (infinite x)))) (test-ok (infinite 0) (nil)) (test-fail ; Modified 1/2014 by Matt K. In CMUCL the stack overflow from (infinite 3) ; aborted an ACL2 (without hons) certification attempt using the standard ; `make' process (via cert.pl), but I was un... | function | xdoc | [
"../unsound-eval",
"centaur/vl/util/print",
"std/util/defconsts"
] | xdoc/tests/unsound-eval-tests.lisp | infinite | |
g () : (vl::with-local-ps (vl::vl-print "Hello"))) (test-ok (g) ("Hello")) | function | xdoc | [
"../unsound-eval",
"centaur/vl/util/print",
"std/util/defconsts"
] | xdoc/tests/unsound-eval-tests.lisp | g |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.