#include "parautil.h"

This page has information from files parautil.h and parautil.c.

Contents


Public Routines in File parautil.c

Index

contains_eqfold_denialnew_constantsame_term_structure
contains_pos_eqinit_paramodorient_equalitiestop_flip
eq_atomliteral_fliporiented_equnfold_order
eq_tautologymark_oriented_eqpos_eqzap_literal_flip
equality_in_clausesmark_renamable_flippos_eq_unitzap_top_flip
equational_defneg_eqpos_equality_in_clauses
equational_def_2neg_eq_unitrenamable_flip_eq
flip_eqneg_nonunit_in_clausesrenamable_flip_eq_test

Details


BOOL contains_eq(Clause c);
This function checks if a clause contains an equality literal (positive or negative) for the purposes of paramodulation and demodulation.
BOOL contains_pos_eq(Clause c);
This function checks if a clause contains a positive equality literal for the purposes of paramodulation and demodulation.
BOOL eq_atom(Term a);
This function checks if an atom is an equality atom (positive or negative) for the purposes of paramodulation and demodulation.
BOOL eq_tautology(Clause c);
This routine returns TRUE if the clause has any literals of the form t=t.
BOOL equality_in_clauses(Plist l);
Does the Plist contain a clause with a positive equality literal?
int equational_def(Clause c);

BOOL equational_def_2(Term alpha, Term beta);

void flip_eq(Term atom, int n);
Flip an equality and update the justification of the containing clause.
Clause fold_denial(Clause c, int alpha_max);

void init_paramod(void);

Literal literal_flip(Literal a);

void mark_oriented_eq(Term atom);
This routine marks an atom as an oriented equality.
void mark_renamable_flip(Term atom);
This routine marks an atom as "renamable_flip".
BOOL neg_eq(Literal lit);
This function checks if a literal is a positive equality for the purposes of paramodulation and demodulation.
BOOL neg_eq_unit(Clause c);
This function checks if a clause is a negative equality unit.
BOOL neg_nonunit_in_clauses(Plist l);
Does the Plist contain a negative nonunit clause ?
Clause new_constant(Clause c);
If the Clause is a positive equality unit a(x) = b(y) with two variables in which one variable occurs in each side, infer a clause a(x) = c with a new constant c. We could also infer b(y)=c, but that will come by other inference mechanisms.
void orient_equalities(Clause c, BOOL allow_flips);
For each equality literal (positive or negative) of Clause c, compare the arguments; if the left is greater, mark the atom as oriented, and if the the right is greater, flip the arguments (add an entry to the justification), and mark the atom as oriented.
BOOL oriented_eq(Term atom);
This function checks if an atom is an oriented equality atom. (The terms are not actually compared. Only the mark is checked.)
BOOL pos_eq(Literal lit);
This function checks if a literal is a positive equality for the purposes of paramodulation and demodulation.
BOOL pos_eq_unit(Clause c);
This function checks if a clause is a positive equality unit for the purposes of paramodulation and demodulation.
BOOL pos_equality_in_clauses(Plist l);
Does the Plist contain a clause with a positive equality literal?
BOOL renamable_flip_eq(Term atom);
This function checks if an atom is a renamable_flip equality atom. (The terms are not actually compared. Only the mark is checked.)
BOOL renamable_flip_eq_test(Term atom);
Test if a term is a renamable-flip equality atom. This does not check the flag; it does the complete test.
BOOL same_term_structure(Term t1, Term t2);
Do terms t1 and t2 have the same structure? That is, if we rename all variables to x, are t1 and t2 identical?
Term top_flip(Term a);
Given a binary term (or atom), return the flip. The two arguments are not copied. When done with it, call zap_top_flip(t) instead of zap_term so that the arguments are not zapped.
Ordertype unfold_order(Term alpha, Term beta);

void zap_literal_flip(Literal a);
Free a literal created by literal_flip.
void zap_top_flip(Term a);
Free a term created by top_flip.

Public Definitions in File parautil.h


Introduction

This package contains a few utilites for paramodulation and demodulation.

These activities are projects of the Mathematics and Computer Science Division of Argonne National Laboratory.