package colibri2

You can search for identifiers within the package.

in-package search v0.2.0

Package contains no libraries

include module type of struct include Dolmen_std.Expr.Term.Const end

A module for constant symbols that occur in terms.

type t = Dolmen_std.Expr.term_cst

The type of constant symbols that can occur in terms

val print : Stdlib.Format.formatter -> t -> unit

Printer.

val hash : t -> int

A hash function for term constants, should be suitable to create hashtables.

val equal : t -> t -> bool

An equality function on term constants. Should be compatible with the hash function.

val compare : t -> t -> int

Comparison function on variables.

val arity : t -> int * int

Returns the arity of a term constant.

val mk : Dolmen_std.Path.t -> Dolmen_std.Expr.Term.ty -> t

Create a constant symbol.

val get_tag : t -> 'a Dolmen_std.Tag.t -> 'a option

Get the value bound to a tag.

val get_tag_list : t -> 'a list Dolmen_std.Tag.t -> 'a list

Get the list of values bound to a list tag, returning the empty list if no value is bound.

val get_tag_last : t -> 'a list Dolmen_std.Tag.t -> 'a option

Get the last value bound to a list tag.

val set_tag : t -> 'a Dolmen_std.Tag.t -> 'a -> unit

Set the value bound to the tag.

val add_tag : t -> 'a list Dolmen_std.Tag.t -> 'a -> unit

Bind an additional value to a list tag.

val add_tag_opt : t -> 'a list Dolmen_std.Tag.t -> 'a option -> unit

Optionally bind an additional value to a list tag.

val add_tag_list : t -> 'a list Dolmen_std.Tag.t -> 'a list -> unit

Bind a list of additional values to a list tag.

val unset_tag : t -> _ Dolmen_std.Tag.t -> unit

Remove the binding to the given tag.

Satisfy the required interface for the typing of tptp's Thf.

include Dolmen_intf.Term.Tptp_Thf_Core_Const with type t := t

val _true : t

The smybol for true

val _false : t

The symbol for false

val neg : t

Negation.

val or_ : t

Binary disjunction of formulas

val and_ : t

Binary conjunction of formulas

val nand : t

Not-and

val nor : t

Not-or

val imply : t

Implication

val implied : t

Reverse implication

val equiv : t

Equivalence

val xor : t

Exclusive disjunction.

val ite : t

ite condition then_t else_t creates a conditional branch.

val eq : t

Build the equality of two terms.

val neq : t

Binary disequality.

val pi : t

Higher-order encoding of universla quantification.

val sigma : t

Higher-order encoding of existancial quantification.

val eqs : int -> t

n-ary equality.

val distinct : int -> t

n-ary disequality.

val _and : int -> t

n-ary conjonction.

val _or : int -> t

n-ary disjunction.

val coerce : t

Type coercion.

val in_interval : (bool * bool) -> t

Interger interval inclusion.

val maps_to : t

Mapping (used in triggers).

module Int = Dolmen_std.Expr.Term.Const.Int

A module for integer constant symbols that occur in terms.

module Rat = Dolmen_std.Expr.Term.Const.Rat

A module for rational constant symbols that occur in terms.

module Real = Dolmen_std.Expr.Term.Const.Real

A module for real constant symbols that occur in terms.

module Array = Dolmen_std.Expr.Term.Const.Array

A module for array constant symbols that occur in terms.

module Bitv = Dolmen_std.Expr.Term.Const.Bitv

A module for bit vector constant symbols that occur in terms.

module Float = Dolmen_std.Expr.Term.Const.Float

A module for floating point constant symbols that occur in terms.

module String = Dolmen_std.Expr.Term.Const.String

A module for string constant symbols that occur in terms.

val pp : Stdlib.Format.formatter -> t -> unit

include sig ... end

val hash_fold_t : t Base.Hash.folder

module M : sig ... end

module S : sig ... end

module H : sig ... end

val sexp_of_t : t -> Base.Sexp.t