A | |
and_ [Ast_zf.Term] | |
and_ [Term_intf.Logic] | |
and_t [Ast_tptp.Term] | |
and_t [Term_intf.Logic] | |
annot [Ast_tptp.Statement] |
Terms as annotations for statements.
|
annot [Ast_smtlib.Term] |
Attach a list of attributes (also called annotations) to a term.
|
annot [Stmt_intf.Logic] |
Constructors for annotations.
|
annot [Term_intf.Logic] |
Attach a list of attributes (also called annotations) to a term.
|
apply [Ast_tptp.Term] |
Application.
|
apply [Ast_zf.Term] |
Application of terms.
|
apply [Ast_smtlib.Term] |
Application.
|
apply [Term_intf.Logic] |
Application constructor, seen as higher order application
rather than first-order application for the following reasons:
being able to parse tptp's THF, having location attached
to function symbols.
|
arrow [Ast_tptp.Term] |
Function type constructor.
|
arrow [Ast_zf.Term] |
Arow, i.e function type constructor, currifyed.
|
arrow [Term_intf.Logic] |
Function type constructor, for curryfied functions.
|
assert_ [Ast_smtlib.Statement] |
Add a proposition to the current set of assertions.
|
assert_ [Stmt_intf.Logic] |
Add an assertion to the current set of assertions.
|
assume [Ast_zf.Statement] | |
assume [Stmt_intf.Logic] |
Adds an hypothesis.
|
atom [Ast_dimacs.Term] |
Make an atom from an non-zero integer.
|
atom [Term_intf.Logic] |
Atoms are used for dimacs cnf parsing.
|
attr [Ast_smtlib.Id] |
The namespace for sorts (also called typee), terms
and attributes, respectively.
|
attr [Id_intf.Logic] |
Namespace used for attributes (also called annotations) in smtlib.
|
B | |
binary [Ast_smtlib.Term] |
Constants lexically recognised as numbers in different formats.
|
binary [Term_intf.Logic] |
Constructors for words defined as numeric formats by the languages
specifications.
|
C | |
check_sat [Ast_smtlib.Statement] |
Solve the current set of assertions for satisfiability.
|
check_sat [Stmt_intf.Logic] |
Directive that instructs the prover to solve the current set of assertions.
|
choice [Ast_tptp.Term] |
Indefinite description, also called choice operator.
|
choice [Term_intf.Logic] | |
clause [Ast_dimacs.Statement] |
Make a clause from a list of literals.
|
clause [Stmt_intf.Logic] |
Add to the current set of assertions the given list of terms as a clause.
|
cnf [Ast_tptp.Statement] |
TPTP statements, used for instance as
tff ~loc ~annot name role t .
|
cnf [Stmt_intf.Logic] |
TPTP directives.
|
colon [Ast_tptp.Term] |
Juxtaposition of terms, usually used for annotating terms with their type.
|
colon [Ast_zf.Term] |
Juxtaposition of terms, usually used for annotating terms with types.
|
colon [Ast_smtlib.Term] |
Juxtaposition of terms, used to annotate terms with their type.
|
colon [Term_intf.Logic] |
Represents juxtaposition of two terms, usually denoted "t : t'"
in most languages, and mainly used to annotated terms with their
supposed, or defined, type.
|
combine [ParseLocation] |
LogtkPosition that spans the two given positions.
|
combine_list [ParseLocation] |
N-ary version of
ParseLocation.combine .
|
compare [Id] |
Usual functions for hashing, comparisons, equality.
|
const [Ast_tptp.Term] |
Make a constant.
|
const [Ast_zf.Term] |
Create a new constant.
|
const [Ast_smtlib.Term] |
Constants, i.e non predefined symbols.
|
const [Term_intf.Logic] |
Variable and constant constructors.
|
D | |
data [Ast_zf.Statement] | |
data [Stmt_intf.Logic] |
Packs a list of mutually recursive inductive type declarations.
|
data_t [Ast_tptp.Term] |
Predefined symbols in tptp.
|
data_t [Term_intf.Logic] |
Term without semantic meaning, used for creating "data" terms.
|
decl [Ast_tptp.Id] |
Names used to refer to tptp phrases.
|
decl [Ast_zf.Statement] | |
decl [Stmt_intf.Logic] |
Symbol declaration.
|
decl [Id_intf.Logic] |
Namespace used for declaration identifiers (for instance used
to filter declarations during includes)
|
definition [Ast_zf.Statement] | |
definition [Stmt_intf.Logic] |
Symbol definition.
|
description [Ast_tptp.Term] |
Definite description.
|
description [Term_intf.Logic] |
Binders for variables.
|
distinct [Ast_tptp.Term] |
Make a constant whose name possibly contain special characters
(All 'distinct' constants name are enclosed in quotes).
|
distinct [Term_intf.Logic] |
Used in tptp to specify constants different from other constants, for instance the
'distinct' "Apple" should be syntactically different from the "Apple"
constant.
|
E | |
enum [Logic.Make] |
Enumeration of languages together with an appropriate
name.
|
eq [Ast_zf.Term] |
Make an equality between terms.
|
eq [Term_intf.Logic] | |
eq [ParseLocation] |
Hash and equality
|
eq_t [Ast_tptp.Term] | |
eq_t [Term_intf.Logic] | |
equal [Id] | |
equiv [Ast_zf.Term] |
Usual propositional functions.
|
equiv [Term_intf.Logic] |
Proposition construction functions.
|
equiv_t [Ast_tptp.Term] | |
equiv_t [Term_intf.Logic] | |
exists [Ast_tptp.Term] |
Existencial porpositional quantification.
|
exists [Ast_zf.Term] |
Existencial porpositional qantification.
|
exists [Ast_smtlib.Term] |
Existencial quantification.
|
exists [Term_intf.Logic] | |
exit [Ast_smtlib.Statement] |
Exit the interactive loop.
|
exit [Stmt_intf.Logic] |
Exit directive (used in interactive mode).
|
F | |
false_ [Ast_zf.Term] |
Standard pre-defined constants.
|
false_ [Term_intf.Logic] |
The constants for the true and false propositional constants.
|
file [Parse_intf.S] |
A function that parses an entire file, i.e until the end-of-file token,
and return the list of parsed statements.
|
find [Logic.Make] |
Tries and find the given file, using the language specification.
|
find [Language_intf.S] |
Helper function to find a file using a language specification.
|
fmt [ParseLocation] | |
fmt_hint [ParseLocation] |
Printing functions
|
fof [Ast_tptp.Statement] | |
fof [Stmt_intf.Logic] | |
forall [Ast_tptp.Term] |
Universal propositional quantification.
|
forall [Ast_zf.Term] |
Universal propositional quantification.
|
forall [Ast_smtlib.Term] |
Universal quantification.
|
forall [Term_intf.Logic] | |
full_name [Id] |
Returns a full name for the identifier.
|
fun_decl [Ast_smtlib.Statement] |
Declares a new term symbol, and its type.
|
fun_decl [Stmt_intf.Logic] |
Symbol declaration.
|
fun_def [Ast_smtlib.Statement] |
Defines a new function.
|
fun_def [Stmt_intf.Logic] |
Symbol definition.
|
fun_ty [Term] |
Multi-arguments function type constructor.
|
G | |
get_assertions [Ast_smtlib.Statement] |
Return the current set of assertions.
|
get_assertions [Stmt_intf.Logic] |
Instructs the prover to print all current assertions.
|
get_assignment [Ast_smtlib.Statement] |
Return the values of asserted propositions which have been labelled using
the ":named" attribute.
|
get_assignment [Stmt_intf.Logic] |
Instructs the prover to return truth assignemnt for labelled formulas (see smtlib manual
for more information).
|
get_info [Ast_smtlib.Statement] |
Get information (see smtlib manual).
|
get_info [Stmt_intf.Logic] | |
get_option [Ast_smtlib.Statement] |
Get the value of a prover option.
|
get_option [Stmt_intf.Logic] | |
get_proof [Ast_smtlib.Statement] |
Return the proof of the lastest
check_sat if it returned unsat, else
is undefined.
|
get_proof [Stmt_intf.Logic] |
If the last call to
check_sat returned UNSAT, then instruct the prover to return
the proof of unsat.
|
get_unsat_core [Ast_smtlib.Statement] |
Return the unsat core of the latest
check_sat if it returned unsat,
else is undefined.
|
get_unsat_core [Stmt_intf.Logic] |
If the last call to
check_sat returned UNSAT, then instruct the prover to return
the unsat core of the unsatisfiability proof, i.e the smallest set of assertions
needed to prove false .
|
get_value [Ast_smtlib.Statement] |
Return the value of the given terms in the current model of the solver.
|
get_value [Stmt_intf.Logic] |
Instructs the prover to return the values of the given closed quantifier-free terms.
|
goal [Ast_zf.Statement] | |
goal [Stmt_intf.Logic] |
The goal, i.e the propositional formula to prove.
|
H | |
hash [ParseLocation] | |
hash [Id] | |
hexa [Ast_smtlib.Term] | |
hexa [Term_intf.Logic] | |
I | |
implied_t [Ast_tptp.Term] | |
implied_t [Term_intf.Logic] | |
implies_t [Ast_tptp.Term] | |
implies_t [Term_intf.Logic] |
Standard logical connectives viewed as terms.
|
imply [Ast_zf.Term] | |
imply [Term_intf.Logic] | |
include_ [Ast_tptp.Statement] |
Include directive.
|
include_ [Stmt_intf.Logic] |
Inlcude directive.
|
inductive [Ast_zf.Statement] | |
inductive [Stmt_intf.Logic] |
Inductive type definitions.
|
input [Parse_intf.S.Incremental] | |
input [Parse_intf.S] |
A function to parse a single statement.
|
int [Ast_tptp.Term] | |
int [Ast_smtlib.Term] | |
int [Term_intf.Logic] | |
ite [Ast_tptp.Term] |
Conditional, of the form
ite condition then_branch els_branch .
|
ite [Term_intf.Logic] |
Conditional constructor, both for first-order terms and propositions.
|
L | |
lambda [Ast_tptp.Term] |
Function construction.
|
lambda [Term_intf.Logic] | |
letin [Ast_tptp.Term] |
Local binding for terms.
|
letin [Ast_zf.Term] |
Local term binding.
|
letin [Ast_smtlib.Term] |
Local bindings.
|
letin [Term_intf.Logic] | |
M | |
mk [Ast_tptp.Id] |
Make an identifier
|
mk [Ast_zf.Id] |
Make identifiers from a namespace and a string.
|
mk [Ast_smtlib.Id] |
Make an identifier from a name and namespace.
|
mk [Id_intf.Logic] |
Make an identifier from its namespace and name.
|
mk [ParseLocation] | |
mk [Id] |
Create an identifier.
|
mk_lexbuf [ParseLocation] |
Reutnrs the lexbuf associetd with the given file or stdin,
with the correct filename.
|
mk_pair [ParseLocation] | |
mk_pos [Location_intf.S] |
Make a position from two lewing positions.
|
mk_pos [ParseLocation] |
Construction functions
|
mod_name [Id_intf.Logic] |
Namespace used by modules (for instance in dedulkti).
|
N | |
nand_t [Ast_tptp.Term] | |
nand_t [Term_intf.Logic] | |
neq_t [Ast_tptp.Term] | |
neq_t [Term_intf.Logic] |
The terms representing equality and disequality, respectively.
|
nor_t [Ast_tptp.Term] | |
nor_t [Term_intf.Logic] | |
not_ [Ast_zf.Term] | |
not_ [Term_intf.Logic] | |
not_t [Ast_tptp.Term] | |
not_t [Term_intf.Logic] | |
O | |
of_extension [Logic.Make] |
These function take as argument either a language, or a filename,
and return a triple: language, language file extension (starting with a dot), appropriate parsing module
Extensions should start with a dot (for instance :
".smt2" )
|
of_language [Logic.Make] | |
of_lexbuf [Location_intf.S] |
Make a position using a lexbuf directly.
|
of_lexbuf [ParseLocation] |
Recover a position from a lexbuf
|
or_ [Ast_zf.Term] | |
or_ [Term_intf.Logic] | |
or_t [Ast_tptp.Term] | |
or_t [Term_intf.Logic] | |
P | |
parse_file [Logic.Make] |
Given a filename, parse the file, and return the detected language
together with the list of statements parsed.
|
parse_file [Language_intf.S] |
Parse the given file.
|
parse_input [Logic.Make] |
Incremental parsing of either a file (see ), or stdin
(with given language).
|
parse_input [Language_intf.S] |
Incremental parsing.
|
pi [Ast_tptp.Term] |
Dependant type constructor, used for polymorphic function types.
|
pi [Ast_zf.Term] |
Dependant product, or polymorphic type quantification.
|
pi [Term_intf.Logic] | |
pop [Ast_smtlib.Statement] |
Pop the given number of level on the stack of assertions.
|
pop [Stmt_intf.Logic] | |
pp [ParseLocation] | |
pp [Statement] | |
pp [Term] | |
pp [Id] | |
print [Statement] |
Printing functions for statements.
|
print [Term] |
Printing functionson buffer and formatters.
|
print [Id] |
Printing functions.
|
product [Ast_tptp.Term] |
Product of types, used for function types with more than one argument.
|
product [Term_intf.Logic] |
Product type constructor, used for instance in the types of
functions that takes multiple arguments in a non-curry way.
|
prop [Ast_zf.Term] | |
prop [Term_intf.Logic] |
The type of propositions.
|
push [Ast_smtlib.Statement] |
Push the given number of new level on the stack of assertions.
|
push [Stmt_intf.Logic] |
Directives for manipulating the set of assertions.
|
R | |
rat [Ast_tptp.Term] | |
rat [Term_intf.Logic] | |
real [Ast_tptp.Term] |
Constants that are syntaxically recognised as numbers.
|
real [Ast_smtlib.Term] | |
real [Term_intf.Logic] | |
rewrite [Ast_zf.Statement] | |
rewrite [Stmt_intf.Logic] |
Declare a rewrite rule, i.e a universally quantified equality or equivalence that
can be oriented according to a specific ordering.
|
S | |
sequent [Ast_tptp.Term] |
Sequents as terms, used as
sequents hyps goals .
|
sequent [Term_intf.Logic] |
Sequents as terms
|
set_file [ParseLocation] |
Change the file name used for positions in this lexbuf
|
set_info [Ast_smtlib.Statement] |
Set information (see smtlib manual).
|
set_info [Stmt_intf.Logic] |
Getter and setter for various informations (see smtlib manual).
|
set_logic [Ast_smtlib.Statement] |
Set the problem logic.
|
set_logic [Stmt_intf.Logic] |
Set the logic to be used for solving.
|
set_option [Ast_smtlib.Statement] |
Set the value of a prover option.
|
set_option [Stmt_intf.Logic] |
Getter and setter for prover options (see smtlib manual).
|
sexpr [Ast_smtlib.Term] |
S-expressions.
|
sexpr [Term_intf.Logic] |
S-expressions (for smtlib attributes), should probably be related
to the
data_t term.
|
smaller [ParseLocation] | smaller p1 p2 is true if p1 is included in p2 , ie
p1 is a sub-location of p2 (interval inclusion)
|
sort [Ast_smtlib.Id] | |
sort [Id_intf.Logic] |
The namespace for sorts (also called types).
|
string_of_language [Logic.Make] |
String representation of the variant
|
subtype [Ast_tptp.Term] |
Comparison of type (used in tptp's THF).
|
subtype [Term_intf.Logic] |
Subtype relation for types.
|
T | |
tType [Ast_zf.Term] | |
tType [Term_intf.Logic] |
The type of types, defined as specific token by the Zipperposition format;
in other languages, will be represented as a constant (the "$tType" constant
in tptp for instance).
|
term [Ast_tptp.Id] |
Usual namespace, used for temrs, types and propositions.
|
term [Ast_zf.Id] |
The naemspace for terms, types, and pretty much everything
|
term [Ast_smtlib.Id] | |
term [Id_intf.Logic] |
The usual namespace for terms.
|
tff [Ast_tptp.Statement] | |
tff [Stmt_intf.Logic] | |
thf [Ast_tptp.Statement] | |
thf [Stmt_intf.Logic] | |
token [Lex_intf.S] |
The function producing token from a lexbuf.
|
tpi [Ast_tptp.Statement] | |
tpi [Stmt_intf.Logic] | |
true_ [Ast_zf.Term] | |
true_ [Term_intf.Logic] | |
type_decl [Ast_smtlib.Statement] |
Declares a new type constructor with given arity.
|
type_decl [Stmt_intf.Logic] |
Type declaration.
|
type_def [Ast_smtlib.Statement] |
Defines an alias for types.
|
type_def [Stmt_intf.Logic] |
Type definition.
|
U | |
union [Ast_tptp.Term] |
Union of types.
|
union [Term_intf.Logic] |
Union type constructor, currently used in tptp's THF format.
|
V | |
var [Ast_tptp.Term] |
Make a variable (in tptp, variable are syntaxically different from constants).
|
var [Term_intf.Logic] | |
W | |
wildcard [Ast_zf.Term] | |
wildcard [Term_intf.Logic] |
The wildcard term, usually used in place of type arguments
to explicit polymorphic functions to not explicit types that
can be inferred by the type-checker.
|
X | |
xor_t [Ast_tptp.Term] | |
xor_t [Term_intf.Logic] |