def get_lemma_files_from_sentences(lemmas_name, sentences): sentences_files = [] sentences_names = [] import math # determine maximal number of digits digits = int(math.ceil(math.log10(len(sentences)))) i = 1 for lemma in sentences: name = lemmas_name + '_goal' + ('{0:0' + str(digits) + 'd}').format(i) filename = filemgt.get_full_path( name, folder=filemgt.read_config('ladr', 'folder'), ending=filemgt.read_config('ladr', 'ending')) output_file = open(filename, 'w') output_file.write('formulas(goals).\n') output_file.write(lemma + '\n') output_file.write('end_of_list.\n') output_file.close() sentences_files.append(filename) sentences_names.append(name) i += 1 return (sentences_names, sentences_files)
def get_lemma_files_from_sentences (lemmas_name, sentences): sentences_files = [] sentences_names = [] import math # determine maximal number of digits digits = int(math.ceil(math.log10(len(sentences)))) i = 1 for lemma in sentences: name = lemmas_name + '_goal' + ('{0:0'+ str(digits) + 'd}').format(i) filename = filemgt.get_full_path(name, folder=filemgt.read_config('ladr','folder'), ending=filemgt.read_config('ladr','ending')) output_file = open(filename, 'w') output_file.write('formulas(goals).\n') output_file.write(lemma + '\n') output_file.write('end_of_list.\n') output_file.close() sentences_files.append(filename) sentences_names.append(name) i += 1 return (sentences_names, sentences_files)
def get_single_ladr_file (self, imports = None): """get the ClifModuleSet as a single file in LADR syntax.""" # if the given imports are identical to the modules imports, treat it as the modules imports were used if imports and set(self.imports).issubset(imports) and set(self.imports).issuperset(imports): imports = None # avoid redundant work if we already have the ladr file if not imports and len(self.p9_file_name)>0: return self.p9_file_name ending = "" if not imports: ending = filemgt.read_config('ladr','all_ending') name = self.module_name else: ending = filemgt.read_config('ladr','select_ending') name = imports[0].module_name # construct the final ending ending += filemgt.read_config('ladr','ending') p9_files = self.get_ladr_files(imports) p9_file_name = filemgt.get_full_path(name, folder=filemgt.read_config('ladr','folder'), ending=ending) if not imports: self.p9_file_name = p9_file_name #print "FILE NAME:" + self.p9_file_name # TODO: need to initialize self.replaceable_symbols ladr.cumulate_ladr_files(p9_files, p9_file_name) logging.getLogger(__name__).info("CREATED SINGLE LADR TRANSLATION: " + p9_file_name) return p9_file_name
def get_single_tptp_file(self, imports=None): """translate the module and all imported modules to a single TPTP file.""" # if the given imports are identical to the modules imports, treat it as the modules imports were used if imports and set(self.imports).issubset(imports) and set( self.imports).issuperset(imports): imports = None ending = "" # avoid redundant work if we already have the tptp file and didn't add a lemma module if not imports: if len(self.tptp_file_name) > 0 and self.lemma_module is None: return self.tptp_file_name ending = filemgt.read_config('tptp', 'all_ending') name = self.module_name else: ending = filemgt.read_config('tptp', 'select_ending') name = imports[0].module_name # construct the final ending ending += filemgt.read_config('tptp', 'ending') tptp_file_name = filemgt.get_full_path(name, folder=filemgt.read_config( 'tptp', 'folder'), ending=ending) if not imports: self.tptp_file_name = tptp_file_name imports = self.get_imports().copy() tptp_sentences = [] if self.lemma_module: imports.remove(self.lemma_module) tptp_sentences.append(self.lemma_module.tptp_sentence) files_to_translate = [i.clif_processed_file_name for i in imports] while None in files_to_translate: files_to_translate.remove(None) tptp_sentences.extend( clif.translate_sentences(files_to_translate, "TPTP")) tptp_file = open(tptp_file_name, 'w') tptp_file.writelines([t + "\n" for t in tptp_sentences]) tptp_file.close() logging.getLogger(__name__).info("CREATED TPTP TRANSLATION: " + tptp_file_name) return tptp_file_name
def get_paradox_cmd (imports,output_stem): """ we only care about the first element in the list of imports, which will we use as base name to obtain a single tptp file of the imports, which is the input for paradox.""" args = [] args.append(filemgt.read_config('paradox','command')) args.append('--time') args.append(filemgt.read_config('paradox','timeout')) args.append('--verbose') args.append('2') args.append('--model') args.append('--tstp') # append all tptp input files args.append(list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)) return (args, [])
def get_p9_cmd(imports, output_stem, option_files=None): """get a formatted command to run Prover9 with options (timeout, etc.) set in the class instance.""" args = [] args.append(filemgt.read_config('prover9', 'command')) args.append('-t' + filemgt.read_config('prover9', 'timeout')) args.append('-f') # append all ladr input files for m in imports: args.append(m.get_p9_file_name()) if option_files: for f in option_files: args.append(f) return (args, [])
def get_p9_cmd (imports,output_stem, option_files = None): """get a formatted command to run Prover9 with options (timeout, etc.) set in the class instance.""" args = [] args.append(filemgt.read_config('prover9','command')) args.append('-t' + filemgt.read_config('prover9','timeout')) args.append('-f') # append all ladr input files for m in imports: args.append(m.get_p9_file_name()) if option_files: for f in option_files: args.append(f) return (args, [])
def get_paradox_cmd(imports, output_stem): """ we only care about the first element in the list of imports, which will we use as base name to obtain a single tptp file of the imports, which is the input for paradox.""" args = [] args.append(filemgt.read_config('paradox', 'command')) args.append('--time') args.append(filemgt.read_config('paradox', 'timeout')) args.append('--verbose') args.append('2') args.append('--model') args.append('--tstp') # append all tptp input files args.append( list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)) return (args, [])
def get_m4_cmd(imports, output_stem): """get a formatted command to run Mace4 with options (timeout, etc.) set in the class instance.""" args = [] args.append(filemgt.read_config('mace4', 'command')) args.append('-v0') args.append('-t' + filemgt.read_config('mace4', 'timeout')) args.append('-s' + filemgt.read_config('mace4', 'timeout_per')) args.append('-n' + filemgt.read_config('mace4', 'start_size')) args.append('-N' + filemgt.read_config('mace4', 'end_size')) args.append('-f') # append all ladr input files for m in imports: args.append(m.get_p9_file_name()) return (args, [])
def get_p9_empty_optionsfile(p9_file_name, verbose=True): # currently one option file for all!! #print 'OPTIONS FILE - P9 file name = ' + p9_file_name options_file_name = os.path.join( os.path.dirname(p9_file_name), os.path.splitext(os.path.basename(p9_file_name))[0] + filemgt.read_config('prover9', 'options_ending')) #print 'OPTIONS FILE = ' + options_file_name ladr.options_files.append(options_file_name) if os.path.isfile(options_file_name): return options_file_name else: # options_file_name = module_p9_file + '.options' options_file = open(options_file_name, 'w') options_file.write('clear(auto_denials).\n') if not verbose: options_file.write('clear(print_initial_clauses).\n') options_file.write('clear(print_kept).\n') options_file.write('clear(print_given).\n') #options_file.write('set(quiet).') options_file.close() return options_file_name
def __init__(self, name, reasoner_type=None, reasoner_id=None): self.identifier = '' self.type = Reasoner.PROVER self.args = [] self.positive_returncodes = [] self.unknown_returncodes = [] self.modules = [] self.input_files = '' self.output_file = '' self.time = -1 self.return_code = None self.output = None self.name = name if reasoner_type: self.type = reasoner_type if reasoner_id: self.identifier = reasoner_id else: self.identifier = name self.positive_returncodes = commands.get_positive_returncodes( self.name) self.unknown_returncodes = commands.get_unknown_returncodes(self.name) self.timeout = filemgt.read_config(self.name, 'timeout')
def run_simple_consistency_check (self, module_name = None, modules = None, options_files = None): """ test the input for consistency by trying to find a model or an inconsistency.""" # want to create a subfolder for the output files outfile_stem = filemgt.get_full_path(self.module_name, folder=filemgt.read_config('output','folder')) if not module_name: module_name = self.module_name if not modules: modules = self.imports # use all imports as default set of modules reasoners = ReasonerSet() reasoners.constructAllCommands(modules, outfile_stem) logging.getLogger(__name__).info("USING " + str(len(reasoners)) + " REASONERS: " + str([r.name for r in reasoners])) # run provers and modelfinders simultaneously and wait until one returns reasoners = process.raceProcesses(reasoners) # this captures our return code (consistent/inconsistent/unknown), not the reasoning processes return code (return_value, fastest_reasoner) = self.consolidate_results(reasoners) if len(modules)==0: self.pretty_print_result(module_name + " (without imports)", return_value) else: self.pretty_print_result(module_name + " (with imports = " + str(modules) + ")", return_value) results = [] results.append((tuple(modules), return_value, fastest_reasoner)) #print str(results) return results
def get_m4_cmd (imports,output_stem): """get a formatted command to run Mace4 with options (timeout, etc.) set in the class instance.""" args = [] args.append(filemgt.read_config('mace4','command')) args.append('-v0') args.append('-t' + filemgt.read_config('mace4','timeout')) args.append('-s' + filemgt.read_config('mace4','timeout_per')) args.append('-n' + filemgt.read_config('mace4','start_size')) args.append('-N' + filemgt.read_config('mace4','end_size')) args.append('-f') # append all ladr input files for m in imports: args.append(m.get_p9_file_name()) return (args, [])
def __init__(self, name, reasoner_type=None, reasoner_id=None): self.identifier = '' self.type = Reasoner.PROVER self.args = [] self.positive_returncodes = [] self.unknown_returncodes = [] self.modules = [] self.input_files = '' self.output_file = '' self.time = -1 self.return_code = None self.output = None self.name = name if reasoner_type: self.type = reasoner_type if reasoner_id: self.identifier = reasoner_id else: self.identifier = name self.positive_returncodes = commands.get_positive_returncodes(self.name) self.unknown_returncodes = commands.get_unknown_returncodes(self.name) self.timeout = filemgt.read_config(self.name,'timeout')
def get_vampire_cmd (imports,ouput_stem): args = [] args.append(filemgt.read_config('vampire','command')) args.append('--mode') args.append('casc') args.append('--proof') args.append('tptp') args.append('-t') args.append(filemgt.read_config('vampire','timeout')) # needed for Windows args.append('--input_file') args.append(list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)) logging.getLogger(__name__).debug("COMMAND FOR vampire IS " + str(args)) # works for linux, not for Windows #return (args, [list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)]) return (args, [])
def constructCommand(self, modules, outfile_stem): """Construct the command to invoke the reasoner.""" self.modules = modules self.output_file = outfile_stem + filemgt.read_config( self.name, 'ending') (self.args, self.input_files) = commands.get_system_command( self.name, modules, self.output_file) return self.args
def get_single_tptp_file (self, imports = None): """translate the module and all imported modules to a single TPTP file.""" # if the given imports are identical to the modules imports, treat it as the modules imports were used if imports and set(self.imports).issubset(imports) and set(self.imports).issuperset(imports): imports = None ending = "" # avoid redundant work if we already have the tptp file and didn't add a lemma module if not imports: if len(self.tptp_file_name)>0 and self.lemma_module is None: return self.tptp_file_name ending = filemgt.read_config('tptp','all_ending') name = self.module_name else: ending = filemgt.read_config('tptp','select_ending') name = imports[0].module_name # construct the final ending ending += filemgt.read_config('tptp','ending') tptp_file_name = filemgt.get_full_path(name, folder=filemgt.read_config('tptp','folder'), ending=ending) if not imports: self.tptp_file_name = tptp_file_name imports = self.get_imports().copy() tptp_sentences = [] if self.lemma_module: imports.remove(self.lemma_module) tptp_sentences.append(self.lemma_module.tptp_sentence) files_to_translate = [i.clif_processed_file_name for i in imports] while None in files_to_translate: files_to_translate.remove(None) tptp_sentences.extend(clif.translate_sentences(files_to_translate, "TPTP")) tptp_file = open(tptp_file_name, 'w') tptp_file.writelines([t+"\n" for t in tptp_sentences]) tptp_file.close() logging.getLogger(__name__).info("CREATED TPTP TRANSLATION: " + tptp_file_name) return tptp_file_name
def detect_systems (self): """Read the active provers from the configuration file.""" # local variables provers = filemgt.read_config('active','provers').split(',') finders = filemgt.read_config('active','modelfinders').split(',') provers = [ s.strip() for s in provers ] finders = [ s.strip() for s in finders ] provers = filter(lambda x: len(x)>0, provers) finders = filter(lambda x: len(x)>0, finders) self.extend([Reasoner(r) for r in provers]) self.extend([Reasoner(r, reasoner_type=Reasoner.MODEL_FINDER) for r in finders]) logging.getLogger(__name__).debug("REASONER SET: " + str(provers+finders)) return True
def get_vampire_cmd(imports, ouput_stem): args = [] args.append(filemgt.read_config('vampire', 'command')) args.append('--mode') args.append('casc') args.append('--proof') args.append('tptp') # args.append('--latex_output') # args.append(filemgt.read_config('vampire','latexfile')) args.append('-t') args.append(filemgt.read_config('vampire', 'timeout')) # needed for Windows args.append('--input_file') args.append( list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)) logging.getLogger(__name__).debug("COMMAND FOR vampire IS " + str(args)) # works for linux, not for Windows #return (args, [list(imports)[0].get_module_set(imports).get_single_tptp_file(imports)]) return (args, [])
def get_single_ladr_file(self, imports=None): """get the ClifModuleSet as a single file in LADR syntax.""" # if the given imports are identical to the modules imports, treat it as the modules imports were used if imports and set(self.imports).issubset(imports) and set( self.imports).issuperset(imports): imports = None # avoid redundant work if we already have the ladr file if not imports and len(self.p9_file_name) > 0: return self.p9_file_name ending = "" if not imports: ending = filemgt.read_config('ladr', 'all_ending') name = self.module_name else: ending = filemgt.read_config('ladr', 'select_ending') name = imports[0].module_name # construct the final ending ending += filemgt.read_config('ladr', 'ending') p9_files = self.get_ladr_files(imports) p9_file_name = filemgt.get_full_path(name, folder=filemgt.read_config( 'ladr', 'folder'), ending=ending) if not imports: self.p9_file_name = p9_file_name #print "FILE NAME:" + self.p9_file_name # TODO: need to initialize self.replaceable_symbols ladr.cumulate_ladr_files(p9_files, p9_file_name) logging.getLogger(__name__).info("CREATED SINGLE LADR TRANSLATION: " + p9_file_name) return p9_file_name
def reformat_urls(lines): """Delete URL prefixes from all import declarations.""" lines = list(lines) prefixes = filemgt.read_config('cl','prefix').split(',') prefixes = [p.strip().strip('"') for p in prefixes] prefixes = sorted([p.strip() for p in prefixes], key=lambda s: len(s), reverse=True) for i in range(0,len(lines)): for prefix in prefixes: if prefix in lines[i]: if not prefix.endswith('/'): prefix = prefix+'/' #print "replacing prefix: " + prefix + " in " + lines[i] lines[i] = lines[i].replace(prefix,'') #print lines[i] return lines
def extract_p9_predicates_and_functions(self): #print 'extract predicates and functions' prover9args = 'prover9 -t 0 -f ' for f in self.imports: prover9args += f.p9_file_name + ' ' options_file = commands.get_p9_empty_optionsfile( self.get_p9_file_name(), verbose=False) prover9args += ' ' + options_file + ' ' # would be better to create a temporary file or read the output stream directly temp_file = self.get_module_name() + '_order' + filemgt.read_config( 'ladr', 'ending') prover9args += ' > ' + temp_file logging.getLogger(__name__).debug(prover9args) process.executeSubprocess(prover9args) order_file = open(temp_file, 'r') line = order_file.readline() predicates = None functions = None while line: if line.find('predicate_order') > -1: predicateline = line[line.find('predicate_order([') + len('predicate_order([') + 1:-4] predicates = predicateline.split() for i in range(len(predicates)): predicates[i] = predicates[i].replace(',', '') line = order_file.readline() functionline = line[line.find('function_order([') + len('function_order([') + 1:-4] functions = functionline.split() for i in range(len(functions)): functions[i] = functions[i].replace(',', '') break line = order_file.readline() order_file.close() #print 'temp file : ' + temp_file #print 'options file : ' + options_file os.remove(temp_file) os.remove(options_file) if predicates and functions: return (predicates, functions) else: return ([], [])
def run_module_consistency_check (self,module): """check a single module for consistency.""" outfile_stem = filemgt.get_full_path(module.module_name, folder=filemgt.read_config('output','folder')) reasoners = ReasonerSet() reasoners.constructAllCommands([module], outfile_stem) logging.getLogger(__name__).info("USING " + str(len(reasoners)) + " REASONERS: " + str([r.name for r in reasoners])) # run provers and modelfinders simultaneously and wait until one returns reasoners = process.raceProcesses(reasoners) (return_value, _) = self.consolidate_results(reasoners) self.pretty_print_result(module.module_name, return_value) return return_value
def reformat_urls(lines): """Delete URL prefixes from all import declarations.""" lines = list(lines) prefixes = filemgt.read_config('cl', 'prefix').split(',') prefixes = [p.strip().strip('"') for p in prefixes] prefixes = sorted([p.strip() for p in prefixes], key=lambda s: len(s), reverse=True) for i in range(0, len(lines)): for prefix in prefixes: if prefix in lines[i]: if not prefix.endswith('/'): prefix = prefix + '/' # print "replacing prefix: " + prefix + " in " + lines[i] lines[i] = lines[i].replace(prefix, '') # print lines[i] return lines
def extract_p9_predicates_and_functions (self): #print 'extract predicates and functions' prover9args = 'prover9 -t 0 -f ' for f in self.imports: prover9args += f.p9_file_name + ' ' options_file = commands.get_p9_empty_optionsfile(self.get_p9_file_name(), verbose=False) prover9args += ' ' + options_file + ' ' # would be better to create a temporary file or read the output stream directly temp_file = self.get_module_name() + '_order' + filemgt.read_config('ladr','ending') prover9args += ' > ' + temp_file logging.getLogger(__name__).debug(prover9args) process.executeSubprocess(prover9args) order_file = open(temp_file, 'r') line = order_file.readline() predicates = None functions = None while line: if line.find('predicate_order') > -1: predicateline = line[line.find('predicate_order([')+len('predicate_order([')+1:-4] predicates = predicateline.split() for i in range(len(predicates)): predicates[i] = predicates[i].replace(',','') line = order_file.readline() functionline = line[line.find('function_order([')+len('function_order([')+1:-4] functions = functionline.split() for i in range(len(functions)): functions[i] = functions[i].replace(',','') break line = order_file.readline() order_file.close() #print 'temp file : ' + temp_file #print 'options file : ' + options_file os.remove(temp_file) os.remove(options_file) if predicates and functions: return (predicates, functions) else: return ([], [])
def run_module_consistency_check(self, module): """check a single module for consistency.""" outfile_stem = filemgt.get_full_path(module.module_name, folder=filemgt.read_config( 'output', 'folder')) reasoners = ReasonerSet() reasoners.constructAllCommands([module], outfile_stem) logging.getLogger(__name__).info("USING " + str(len(reasoners)) + " REASONERS: " + str([r.name for r in reasoners])) # run provers and modelfinders simultaneously and wait until one returns reasoners = process.raceProcesses(reasoners) (return_value, _) = self.consolidate_results(reasoners) self.pretty_print_result(module.module_name, return_value) return return_value
def run_simple_consistency_check(self, module_name=None, modules=None, options_files=None): """ test the input for consistency by trying to find a model or an inconsistency.""" # want to create a subfolder for the output files outfile_stem = filemgt.get_full_path(self.module_name, folder=filemgt.read_config( 'output', 'folder')) if not module_name: module_name = self.module_name if not modules: modules = self.imports # use all imports as default set of modules reasoners = ReasonerSet() reasoners.constructAllCommands(modules, outfile_stem) logging.getLogger(__name__).info("USING " + str(len(reasoners)) + " REASONERS: " + str([r.name for r in reasoners])) # run provers and modelfinders simultaneously and wait until one returns reasoners = process.raceProcesses(reasoners) # this captures our return code (consistent/inconsistent/unknown), not the reasoning processes return code (return_value, fastest_reasoner) = self.consolidate_results(reasoners) if len(modules) == 0: self.pretty_print_result(module_name + " (without imports)", return_value) else: self.pretty_print_result( module_name + " (with imports = " + str(modules) + ")", return_value) results = [] results.append((tuple(modules), return_value, fastest_reasoner)) #print str(results) return results
def get_returncodes (name,type="positive_returncode"): code_list = filemgt.read_config(name,type) codes = [] if len(code_list)>0: codes = [ int(s.strip()) for s in code_list.split(',')] return codes
def get_p9_empty_optionsfile (p9_file_name, verbose=True): # currently one option file for all!! #print 'OPTIONS FILE - P9 file name = ' + p9_file_name options_file_name = os.path.join(os.path.dirname(p9_file_name), os.path.splitext(os.path.basename(p9_file_name))[0] + filemgt.read_config('prover9','options_ending')) #print 'OPTIONS FILE = ' + options_file_name ladr.options_files.append(options_file_name) if os.path.isfile(options_file_name): return options_file_name else: # options_file_name = module_p9_file + '.options' options_file = open(options_file_name, 'w') options_file.write('clear(auto_denials).\n') if not verbose: options_file.write('clear(print_initial_clauses).\n') options_file.write('clear(print_kept).\n') options_file.write('clear(print_given).\n') #options_file.write('set(quiet).') options_file.close() return options_file_name
def get_ladr_to_tptp_cmd(input_file_name, output_file_name): cmd = filemgt.read_config( 'converters', 'prover9-to-tptp') + ' < ' + input_file_name + ' > ' + output_file_name return cmd
def get_ladr_to_tptp_cmd (input_file_name, output_file_name): cmd = filemgt.read_config('converters','prover9-to-tptp') + ' < ' + input_file_name + ' > ' + output_file_name return cmd
from src import filemgt from tasks import * import os, sys from src.ClifModuleSet import ClifModuleSet from tasks import clif_to_tptp #global variables filemgt.start_logging() tempfolder = filemgt.read_config('converters', 'tempfolder') ignores = [tempfolder] ending = filemgt.read_config('cl','ending') licence.print_terms() if __name__ == '__main__': options = sys.argv options.reverse() options.pop() folder = options.pop() ladr_all(folder, options) # for directory, subdirs, files in os.walk(folder): # if any(ignore in directory for ignore in ignores): # pass # else: # for single_file in files: # if single_file.endswith(ending): # filename = os.path.join(directory.replace('qs\\',''), single_file) # print filename # m = ClifModuleSet(filename) # clif_to_ladr.ladr(filename, m, options)
def constructCommand (self, modules, outfile_stem): """Construct the command to invoke the reasoner.""" self.modules = modules self.output_file = outfile_stem + filemgt.read_config(self.name,'ending') (self.args, self.input_files) = commands.get_system_command(self.name, modules, self.output_file) return self.args
def get_returncodes(name, type="positive_returncode"): code_list = filemgt.read_config(name, type) codes = [] if len(code_list) > 0: codes = [int(s.strip()) for s in code_list.split(',')] return codes
def nontrivially_consistent(filename, options=[]): (consistent, m) = check_consistency.consistent(filename, options) if consistent==None or consistent==True: # no need to check nontrivial consistency of it is not consistent at all #m = ClifModuleSet(filename) definitional_modules = [] if "-simple" in options: i = m.get_top_module() if "-defs" not in options or i.is_simple_definition(): definitional_modules.append(i) else: for i in m.get_imports(): if "-defs" not in options or i.is_simple_definition(): definitional_modules.append(i) weak = "strong" defs = "" if "-weak" in options: weak = "weak" if "-defs" in options: defs = "definitional " print "\n+++++++++++++++++++++\nProving "+weak +" nontrivial consistency for all " + str(len(definitional_modules)) + " " + defs + "modules of "+ m.get_module_name() +":\n+++++++++++++++++++++" for n in definitional_modules: print n.module_name print "+++++++++++++++++++++\n" if len(definitional_modules)==0: print "NO DEFINITIONS FOUND TO CHECK NONTRIVIAL CONSISTENCY FOR." for i in definitional_modules: if "-defs" not in options or i.is_simple_definition(): if "-defs" in options: if "-all" in options: defined_symbols = m.get_defined_nonlogical_symbols() else: defined_symbols = i.get_defined_symbols() else: # not just definitions if "-all" in options: defined_symbols = m.get_nonlogical_symbols() else: defined_symbols = i.get_nonlogical_symbols() symbol_string = "" for (symbol, arity) in defined_symbols: symbol_string += symbol + '('+ str(arity) + ') ' print "\n+++++++++++++++++++++\nProving "+weak +" nontrivial consistency of nonlogical symbols " + symbol_string + " in module " + i.module_name + "\n+++++++++++++++++++++\n" #for (symbol, arity) in defined_symbols: #print "Symbol " + str(symbol) + " has arity " + str(arity) # need to create new CL file that imports the definition module and adds a sentence stating that n distinct elements in this relation exist module_name_modifier = "" if "-all" in options: module_name_modifier += "_all" if "-weak" in options: module_name_modifier += "_weak" (module_name, path) = filemgt.get_path_with_ending_for_nontrivial_consistency_checks(i.module_name+module_name_modifier) now = datetime.datetime.now() clif_file = open(path, 'w') clif_file.write("/** AUTOMATICALLY CREATED BY MACLEOD ON " + now.strftime("%a %b %d %H:%M:%S %Y")+'**/\n\n') clif_file.write('(' + clif.CLIF_TEXT + ' ' + module_name + '\n\n') clif_file.write('(' + clif.CLIF_IMPORT + ' ' + i.module_name + filemgt.read_config('cl','ending') + ')\n\n') # constructing a sentence of the form: # (exists (x1 x2 ...) # (and # (SYMBOL x1 x2 ...) # (not (= x1 x2)) # (not (= ... # ) ) # # The assumption here is that there must exist a possibility that all the participating elements are distinct. # If this weren't the case, the n-ary predicate could be reduced to a (n-1)-ary predicate. This may be overly simplistic, but works for most of the case. # In particular, it fails if a binary relation is strictly reflexive, i.e. holds only for individual elements. # For predicates with n>2 this should probably be relaxed to: # every pairwise position of elements can be distinct. for (symbol, arity) in defined_symbols: if arity>0: if "-weak" in options: # weak nontrivial consistency: each entity is independent from all others for n in range(arity): clif_file.write(construct_existential_sentence(symbol, arity, negation=False, all_distinct=False, position=n) + '\n\n') clif_file.write(construct_existential_sentence(symbol, arity, negation=True, all_distinct=False, position=n) + '\n\n') else: # strong nontrivial consistency: all participating entities have to be disjoint clif_file.write(construct_existential_sentence(symbol, arity, negation=False, all_distinct=True) + '\n\n') clif_file.write(construct_existential_sentence(symbol, arity, negation=True, all_distinct=True) + '\n\n') clif_file.write(')\n') # closing "cl-module" clif_file.close() check_consistency.consistent(path,options)
from src import filemgt from tasks import * import os, sys from src.ClifModuleSet import ClifModuleSet from tasks import clif_to_tptp #global variables filemgt.start_logging() tempfolder = filemgt.read_config('converters', 'tempfolder') ignores = [tempfolder] ending = filemgt.read_config('cl','ending') licence.print_terms() if __name__ == '__main__': options = sys.argv options.reverse() options.pop() folder = options.pop() tptp_all(folder, options) # for directory, subdirs, files in os.walk(folder): # if any(ignore in directory for ignore in ignores): # pass # else: # for single_file in files: # if single_file.endswith(ending): # filename = os.path.join(directory.replace('qs\\',''), single_file) # print filename # m = ClifModuleSet(filename) # clif_to_ladr.ladr(filename, m, options)
def nontrivially_consistent(filename, m, options=[]): (consistent, m) = check_consistency.consistent(filename, m, options) if consistent==None or consistent==True: # no need to check nontrivial consistency if it is not consistent at all #m = ClifModuleSet(filename) definitional_modules = [] if "-simple" in options: i = m.get_top_module() if "-defs" not in options or i.is_simple_definition(): definitional_modules.append(i) else: for i in m.get_imports(): if "-defs" not in options or i.is_simple_definition(): definitional_modules.append(i) weak = "strong" defs = "" if "-weak" in options: weak = "weak" if "-defs" in options: defs = "definitional " print "\n+++++++++++++++++++++\nProving "+weak +" nontrivial consistency for all " + str(len(definitional_modules)) + " " + defs + "modules of "+ m.get_module_name() +":\n+++++++++++++++++++++" for n in definitional_modules: print n.module_name print "+++++++++++++++++++++\n" if len(definitional_modules)==0: print "NO DEFINITIONS FOUND TO CHECK NONTRIVIAL CONSISTENCY FOR." for i in definitional_modules: if "-defs" not in options or i.is_simple_definition(): if "-defs" in options: if "-all" in options: defined_symbols = m.get_defined_nonlogical_symbols() else: defined_symbols = i.get_defined_symbols() else: # not just definitions if "-all" in options: defined_symbols = m.get_nonlogical_symbols() else: defined_symbols = i.get_nonlogical_symbols() symbol_string = "" for (symbol, arity) in defined_symbols: symbol_string += symbol + '('+ str(arity) + ') ' print "\n+++++++++++++++++++++\nProving "+weak +" nontrivial consistency of nonlogical symbols " + symbol_string + " in module " + i.module_name + "\n+++++++++++++++++++++\n" #for (symbol, arity) in defined_symbols: #print "Symbol " + str(symbol) + " has arity " + str(arity) # need to create new CL file that imports the definition module and adds a sentence stating that n distinct elements in this relation exist module_name_modifier = "" if "-all" in options: module_name_modifier += "_all" if "-weak" in options: module_name_modifier += "_weak" (module_name, path) = filemgt.get_path_with_ending_for_nontrivial_consistency_checks(i.module_name+module_name_modifier) now = datetime.datetime.now() clif_file = open(path, 'w') clif_file.write("/** AUTOMATICALLY CREATED BY MACLEOD ON " + now.strftime("%a %b %d %H:%M:%S %Y")+'**/\n\n') clif_file.write('(' + clif.CLIF_TEXT + ' ' + module_name + '\n\n') clif_file.write('(' + clif.CLIF_IMPORT + ' ' + i.module_name + filemgt.read_config('cl','ending') + ')\n\n') # constructing a sentence of the form: # (exists (x1 x2 ...) # (and # (SYMBOL x1 x2 ...) # (not (= x1 x2)) # (not (= ... # ) ) # # The assumption here is that there must exist a possibility that all the participating elements are distinct. # If this weren't the case, the n-ary predicate could be reduced to a (n-1)-ary predicate. This may be overly simplistic, but works for most of the case. # In particular, it fails if a binary relation is strictly reflexive, i.e. holds only for individual elements. # For predicates with n>2 this should probably be relaxed to: # every pairwise position of elements can be distinct. for (symbol, arity) in defined_symbols: if arity>0: if "-weak" in options: # weak nontrivial consistency: each entity is independent from all others for n in range(arity): clif_file.write(construct_existential_sentence(symbol, arity, negation=False, all_distinct=False, position=n) + '\n\n') clif_file.write(construct_existential_sentence(symbol, arity, negation=True, all_distinct=False, position=n) + '\n\n') else: # strong nontrivial consistency: all participating entities have to be disjoint clif_file.write(construct_existential_sentence(symbol, arity, negation=False, all_distinct=True) + '\n\n') clif_file.write(construct_existential_sentence(symbol, arity, negation=True, all_distinct=True) + '\n\n') clif_file.write(')\n') # closing "cl-module" clif_file.close() m2 = ClifModuleSet(path) check_consistency.consistent(path, m2, options=options)