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.
|
| assumption [Ast_iCNF.Statement] |
Generate a solve instruction with the given list of assumptions.
|
| assumption [Stmt_intf.Logic] |
Solve the current set of assertions, with the given assumptions.
|
| atom [Ast_iCNF.Term] |
Make an atom from an non-zero integer.
|
| 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_iCNF.Statement] |
Make a clause from a list of literals.
|
| 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 | |
| p_cnf [Ast_dimacs.Statement] |
Header of a dimacs file.
|
| p_cnf [Stmt_intf.Logic] |
Header of dimacs files.
|
| 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] |