#include "just.h"

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

Contents


Public Routines in File just.c

Index

append_justfix_input_justjmap2para_just_rev_copy
back_demod_justflip_justjust_countproof_length
back_unit_deletion_justfprint_just_memmap_justresolve_just
binary_res_justget_clause_ancestorsmark_parents_as_usedsb_write_just
clausify_justget_justmerge_justunit_del_just
copy_justget_parajustnew_symbol_justxx_just
copy_justificationget_parentsp_justxxres_just
demod_justinput_justp_just_memzap_just
factor_justjmap1para_just

Details


Just append_just(Just j1, Just j2);
This appends two justifications. No copying occurs.
Just back_demod_just(Clause c);
This routine builds and returns a justification list for back_demod.
Just back_unit_deletion_just(Clause c);
This routine builds and returns a justification list for back_unit_deletion.
Just binary_res_just(Clause c1, int n1, Clause c2, int n2);
This routine builds and returns a justification list for binary resolution. (Binary res justifications may also be constructed in resolve(), along with hyper and UR.)
Just clausify_just(void);
This routine builds and returns a justification list for clausify.
Just copy_just(Clause c);
This routine builds and returns a justification list for copy.
Just copy_justification(Just j);
Copy a justification.
Just demod_just(Ilist g);
This routine builds and returns a justification list for demodulation. The given ilist is not copied.
Just factor_just(Clause c, int lit1, int lit2);
This routine builds and returns a justification list for a factorization.
void fix_input_just(Clause c);
If the clause's justification is simply a copy, replace the justification with the justification of the parent. This is intended for input clauses for which the pre_processing does nothing. The purpose is simply to prevent duplicate steps when printing proofs.
Just flip_just(int n);
This routine builds and returns a justification for equality flipping.
void fprint_just_mem(FILE *fp, BOOL heading);
This routine prints (to FILE *fp) memory usage statistics for data types associated with the just package. The Boolean argument heading tells whether to print a heading on the table.
Plist get_clause_ancestors(Clause c);
This routine returns the Plist of clauses that are ancestors of Clause c, including clause c. The result is sorted (increasing) by ID. If any of the ancestors are compressed, they are uncompressed (in place) and left uncompressed.
Just get_just(void);

Parajust get_parajust(void);

Ilist get_parents(Clause c);
This routine returns the Ilist of parent IDs of the clause.
Just input_just(void);
This routine builds and returns a justification list for input.
int jmap1(Ilist map, int i);
A jmap maps ints to pairs of ints. This returns the first. If i is not in the map, i is returned.
char *jmap2(Ilist map, int i, char *a);
A jmap maps ints to pairs of ints. This returns a string representation of the second. If i is not in the map, or if the int value of is INT_MIN, "" is returned. Starting with 0, the strings are "A" - "Z", "A26", "A27", ... . The argument *a must point to available space for the result. The result is returned.
int just_count(Just j);
Return the number of justification elements in a justtification.
void map_just(Just just, Ilist map);
Update the clause IDs in a justification according to the map.
void mark_parents_as_used(Clause c);

Just merge_just(int n);
This routine builds and returns a justification for the merging a literal. The n-th literal has been removed because it is identical to another literal.
Just new_symbol_just(Clause c);
This routine builds and returns a justification list for new_symbol inference.
void p_just(Just j);

void p_just_mem();
This routine prints (to stdout) memory usage statistics for data types associated with the just package.
Just para_just(Just_type rule,
	       Clause from, Ilist from_vec,
	       Clause into, Ilist into_vec);
This routine builds and returns a justification list for a paramodulation inference. The position vectors are not copied.
Just para_just_rev_copy(Just_type rule,
			Clause from, Ilist from_vec,
			Clause into, Ilist into_vec);
This routine builds and returns a justification list for a paramodulation inference. The position vectors are copied and reversed.
int proof_length(Plist proof);

Just resolve_just(Ilist g, Just_type type);
This routine builds and returns a justification for resolution rules. This handles binary, hyper, ur, and maybe others.
void sb_write_just(String_buf sb, Just just, Ilist map);
This routine writes (to a String_buf) a clause justification. No whitespace is printed before or after.
Just unit_del_just(Clause deleter, int literal_num);
This routine builds and returns a justification list for a factorization.
Just xx_just(int n);
This routine builds and returns a justification for the XX rule, which removes literals that are instances of x!=x.
Just xxres_just(Clause c, int lit);
This routine builds and returns a justification list for resolution with x=x.
void zap_just(Just just);
This routine frees a justification list, including any sublists.

Public Definitions in File just.h

typedef enum {
  INPUT_JUST,         /* Primary               */
  CLAUSIFY_JUST,      /* Primary               */
  COPY_JUST,          /* Primary    int        */
  BACK_DEMOD_JUST,    /* Primary    int        */
  BACK_UNIT_DEL_JUST, /* Primary    int        */
  NEW_SYMBOL_JUST,    /* Primary    int        */
  BINARY_RES_JUST,    /* Primary    Ilist      */
  HYPER_RES_JUST,     /* Primary    Ilist      */
  UR_RES_JUST,        /* Primary    Ilist      */
  FACTOR_JUST,        /* Primary    Ilist      */
  XXRES_JUST,         /* Primary    Ilist      */
  PARA_JUST,          /* Primary    Parajust   */
  PARA_FX_JUST,       /* Primary    Parajust   */
  PARA_IX_JUST,       /* Primary    Parajust   */
  PARA_FX_IX_JUST,    /* Primary    Parajust   */

  DEMOD_JUST,         /* Secondary  Ilist      */
  UNIT_DEL_JUST,      /* Secondary  Ilist      */
  FLIP_JUST,          /* Secondary  int        */
  XX_JUST,            /* Secondary  int        */
  MERGE_JUST          /* Secondary  int        */

} Just_type;

typedef struct parajust * Parajust;

struct parajust {
  int from_id;
  int into_id;
  Ilist from_pos;
  Ilist into_pos;
};

typedef struct just * Just;

struct just {
  Just_type type;
  Just next;
  union {
    int id;
    Ilist lst;
    Parajust para;
  } u;
};

/* A justification starts with a Primary part and then
   has a sequence (maybe none) of Secondary parts.
   Each type has some data, an integer or Ilist (integer
   list) giving clause IDs, or positions of literals or
   subterms.
*/


Introduction


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