Browse Source

Support comments and don’t touch input more than necessary

master
Patrick Lühne 3 years ago
parent
commit
b0173a7b9a
Signed by: patrick
GPG Key ID: 05F3611E97A70ABF
  1. 2
      foliage
  2. 42
      src/format.rs
  3. 92
      src/format_tptp.rs
  4. 119
      src/main.rs
  5. 73
      src/parse.rs
  6. 17
      src/project.rs

2
foliage

@ -1 +1 @@
Subproject commit 5070965bfee7ad8a0af0d4abc0f8c6d07b7ae5ec
Subproject commit 8a7bd651b217a37f6d95faaa2d4bc1221631e88b

42
src/format.rs

@ -19,45 +19,17 @@ impl std::fmt::Display for crate::project::StatementKind
}
}
impl std::fmt::Debug for crate::Project
impl<'input> std::fmt::Debug for crate::Project<'input>
{
fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
{
let mut line_separator = "";
let mut section_separator = "";
if let Some(axioms) = self.statements.get(&crate::project::StatementKind::Axiom)
{
for axiom in axioms
{
write!(format, "{}{:?}: {:?}.", line_separator, crate::project::StatementKind::Axiom, axiom)?;
line_separator = "\n";
}
section_separator = "\n";
}
if let Some(lemmas) = self.statements.get(&crate::project::StatementKind::Lemma)
for block in &self.blocks
{
write!(format, "{}", section_separator)?;
for lemma in lemmas
{
write!(format, "{}{:?}: {:?}.", line_separator, crate::project::StatementKind::Lemma, lemma)?;
line_separator = "\n";
}
section_separator = "\n";
}
if let Some(conjectures) = self.statements.get(&crate::project::StatementKind::Conjecture)
{
write!(format, "{}", section_separator)?;
for conjecture in conjectures
match block
{
write!(format, "{}{:?}: {:?}.", line_separator, crate::project::StatementKind::Conjecture, conjecture)?;
line_separator = "\n";
crate::project::Block::Whitespace(ref text) => write!(format, "{}", text)?,
crate::project::Block::Statement(ref statement) =>
write!(format, "{}", statement.original_text)?,
}
}
@ -65,7 +37,7 @@ impl std::fmt::Debug for crate::Project
}
}
impl std::fmt::Display for crate::Project
impl<'input> std::fmt::Display for crate::Project<'input>
{
fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
{

92
src/format_tptp.rs

@ -72,12 +72,23 @@ fn collect_predicate_declarations_in_project<'a>(project: &'a crate::Project)
{
let mut predicate_declarations = std::collections::HashSet::new();
for (_, formulas) in project.statements.iter()
let formulas = project.blocks.iter()
.filter_map(
|block|
match block
{
crate::project::Block::Whitespace(_) => None,
crate::project::Block::Statement(ref statement) =>
match statement.kind
{
crate::project::StatementKind::Axiom => Some(&statement.formula),
_ => None,
}
});
for formula in formulas
{
for formula in formulas.iter()
{
collect_predicate_declarations_in_formula(&mut predicate_declarations, formula);
}
collect_predicate_declarations_in_formula(&mut predicate_declarations, formula);
}
predicate_declarations
@ -193,12 +204,24 @@ fn collect_symbolic_constants_in_project<'a>(project: &'a crate::Project)
{
let mut symbolic_constants = std::collections::HashSet::new();
for (_, formulas) in project.statements.iter()
// TODO: avoid code duplication
let formulas = project.blocks.iter()
.filter_map(
|block|
match block
{
crate::project::Block::Whitespace(_) => None,
crate::project::Block::Statement(ref statement) =>
match statement.kind
{
crate::project::StatementKind::Axiom => Some(&statement.formula),
_ => None,
}
});
for formula in formulas
{
for formula in formulas.iter()
{
collect_symbolic_constants_in_formula(&mut symbolic_constants, formula);
}
collect_symbolic_constants_in_formula(&mut symbolic_constants, formula);
}
symbolic_constants
@ -209,10 +232,10 @@ struct PredicateDeclarationDisplay<'a>(&'a foliage::PredicateDeclaration);
struct TermDisplay<'a>(&'a foliage::Term);
struct FormulaDisplay<'a>(&'a foliage::Formula);
struct StatementKindDisplay<'a>(&'a crate::project::StatementKind);
pub struct ProjectDisplay<'a>
pub struct ProjectDisplay<'a, 'input>
{
project: &'a crate::project::Project,
conjecture: (crate::project::StatementKind, &'a foliage::Formula),
project: &'a crate::project::Project<'input>,
conjecture: &'a crate::project::Statement<'input>,
}
impl<'a> DisplayTPTP<'a, VariableDeclarationDisplay<'a>> for foliage::VariableDeclaration
@ -255,8 +278,8 @@ impl<'a> DisplayTPTP<'a, StatementKindDisplay<'a>> for crate::project::Statement
}
}
pub fn display_project_with_conjecture_tptp<'a>(project: &'a crate::Project,
conjecture: (crate::project::StatementKind, &'a foliage::Formula)) -> ProjectDisplay<'a>
pub fn display_project_with_conjecture_tptp<'a, 'input>(project: &'a crate::Project<'input>,
conjecture: &'a crate::project::Statement<'input>) -> ProjectDisplay<'a, 'input>
{
ProjectDisplay
{
@ -554,7 +577,7 @@ impl<'a> std::fmt::Display for StatementKindDisplay<'a>
}
}
impl<'a> std::fmt::Debug for ProjectDisplay<'a>
impl<'a, 'input> std::fmt::Debug for ProjectDisplay<'a, 'input>
{
fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
{
@ -593,40 +616,49 @@ impl<'a> std::fmt::Debug for ProjectDisplay<'a>
}
}
if let Some(axioms) = self.project.statements.get(&crate::project::StatementKind::Axiom)
{
write_title(format, "\n\n", "axioms")?;
let axioms = self.project.blocks.iter()
.filter_map(
|block|
match block
{
crate::project::Block::Whitespace(_) => None,
crate::project::Block::Statement(ref statement) =>
match statement.kind
{
crate::project::StatementKind::Axiom => Some(statement),
_ => None,
}
});
for axiom in axioms
{
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Axiom.display_tptp(), axiom.display_tptp())?;
}
for axiom in axioms
{
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Axiom.display_tptp(), axiom.formula.display_tptp())?;
}
match self.conjecture
match self.conjecture.kind
{
(crate::project::StatementKind::Lemma, ref lemma) =>
crate::project::StatementKind::Lemma =>
{
write_title(format, "\n\n", "lemma")?;
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Lemma.display_tptp(), lemma.display_tptp())?;
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Lemma.display_tptp(), self.conjecture.formula.display_tptp())?;
Ok(())
},
(crate::project::StatementKind::Conjecture, ref conjecture) =>
crate::project::StatementKind::Conjecture =>
{
write_title(format, "\n\n", "conjecture")?;
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Conjecture.display_tptp(), conjecture.display_tptp())?;
write!(format, "\ntff({:?}, {:?}).", crate::project::StatementKind::Conjecture.display_tptp(), self.conjecture.formula.display_tptp())?;
Ok(())
},
(crate::project::StatementKind::Axiom, _) => panic!("unexpected axiom"),
crate::project::StatementKind::Axiom => panic!("unexpected axiom"),
}
}
}
impl<'a> std::fmt::Display for ProjectDisplay<'a>
impl<'a, 'input> std::fmt::Display for ProjectDisplay<'a, 'input>
{
fn fmt(&self, format: &mut std::fmt::Formatter) -> std::fmt::Result
{

119
src/main.rs

@ -19,28 +19,41 @@ fn backup_file_path(file_path: &std::path::Path) -> Result<std::path::PathBuf, a
}
}
fn find_conjecture<'a>(project: &'a ask_dracula::Project) -> Option<(ask_dracula::project::StatementKind, &'a foliage::Formula)>
fn find_conjecture<'a, 'input>(project: &'a ask_dracula::Project<'input>) -> Option<&'a ask_dracula::project::Statement<'input>>
{
if let Some(lemmas) = project.statements.get(&ask_dracula::project::StatementKind::Lemma)
for block in &project.blocks
{
if let Some(lemma) = lemmas.first()
if let ask_dracula::project::Block::Statement(ref statement) = block
{
return Some((ask_dracula::project::StatementKind::Lemma, lemma));
if statement.kind == ask_dracula::project::StatementKind::Lemma
|| statement.kind == ask_dracula::project::StatementKind::Conjecture
{
return Some(statement)
}
}
}
if let Some(conjectures) = project.statements.get(&ask_dracula::project::StatementKind::Conjecture)
None
}
fn find_conjecture_mut<'a, 'input>(project: &'a mut ask_dracula::Project<'input>) -> Option<&'a mut ask_dracula::project::Statement<'input>>
{
for block in &mut project.blocks
{
if let Some(conjecture) = conjectures.first()
if let ask_dracula::project::Block::Statement(ref mut statement) = block
{
return Some((ask_dracula::project::StatementKind::Conjecture, conjecture));
if statement.kind == ask_dracula::project::StatementKind::Lemma
|| statement.kind == ask_dracula::project::StatementKind::Conjecture
{
return Some(statement)
}
}
}
None
}
enum VampireResult
enum ProofResult
{
ProofNotFound,
Refutation,
@ -48,7 +61,7 @@ enum VampireResult
}
fn run_vampire<I, S>(input: &str, arguments: Option<I>)
-> Result<VampireResult, ask_dracula::Error>
-> Result<ProofResult, ask_dracula::Error>
where I: IntoIterator<Item = S>, S: AsRef<std::ffi::OsStr>
{
let mut vampire = std::process::Command::new("vampire");
@ -59,6 +72,8 @@ fn run_vampire<I, S>(input: &str, arguments: Option<I>)
None => &mut vampire,
};
//eprintln!("{}", input);
let mut vampire = vampire
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
@ -89,7 +104,7 @@ fn run_vampire<I, S>(input: &str, arguments: Option<I>)
if proof_not_found_regex.is_match(stdout)
{
return Ok(VampireResult::ProofNotFound);
return Ok(ProofResult::ProofNotFound);
}
return Err(ask_dracula::Error::new_run_vampire(
@ -100,7 +115,7 @@ fn run_vampire<I, S>(input: &str, arguments: Option<I>)
if refutation_regex.is_match(stdout)
{
return Ok(VampireResult::Refutation);
return Ok(ProofResult::Refutation);
}
Err(ask_dracula::Error::new_interpret_vampire_output(stdout.to_string(), stderr.to_string()))
@ -121,52 +136,60 @@ fn main() -> Result<(), Box<dyn std::error::Error>>
let (_, mut project) = ask_dracula::parse::project(&file_content)
.map_err(|_| "couldn’t parse input file")?;
match find_conjecture(&project)
let conjecture = find_conjecture(&project);
let vampire_result = match conjecture
{
None =>
{
eprintln!("no lemma or conjecture found, nothing to do");
return Ok(());
},
Some(ref conjecture) =>
{
eprintln!("verifying conjecture: {}", conjecture.formula);
let tptp_content = format!("{}", ask_dracula::format_tptp::display_project_with_conjecture_tptp(&project, conjecture));
run_vampire(&tptp_content, matches.values_of("vampire_arguments").map(|value| value))?
},
};
let conjecture = find_conjecture_mut(&mut project).unwrap();
match vampire_result
{
ProofResult::ProofNotFound =>
{
println!("proof not found");
Ok(())
},
Some((ref statement_kind, ref conjecture)) =>
ProofResult::Refutation =>
{
eprintln!("verifying conjecture: {}", conjecture);
println!("conjecture proven");
let tptp_content = format!("{}", ask_dracula::format_tptp::display_project_with_conjecture_tptp(&project, (statement_kind.clone(), conjecture)));
conjecture.kind = ask_dracula::project::StatementKind::Axiom;
let replace_statement_kind_regex = regex::Regex::new(r"(conjecture|lemma)").unwrap();
let new_text = replace_statement_kind_regex.replace(conjecture.original_text, "axiom");
conjecture.original_text = &new_text;
match run_vampire(&tptp_content, matches.values_of("vampire_arguments").map(|value| value))?
{
VampireResult::ProofNotFound =>
{
println!("proof not found");
Ok(())
},
VampireResult::Refutation =>
{
println!("conjecture proven");
let axiom = project.statements.get_mut(statement_kind).unwrap().remove(0);
project.statements.entry(ask_dracula::project::StatementKind::Axiom).or_insert_with(Vec::new).push(axiom);
let backup_file_path = backup_file_path(file_path)?;
// Make backup of old file
std::fs::rename(file_path, backup_file_path)
.map_err(|error| ask_dracula::Error::new_write_file(file_path.to_owned(), error))?;
// Write updated version of the file
let file_content = format!("{}", project);
std::fs::write(file_path, &file_content)
.map_err(|error| ask_dracula::Error::new_write_file(file_path.to_owned(), error))?;
Ok(())
},
VampireResult::Satisfiable =>
{
println!("conjecture disproven");
Ok(())
},
}
let backup_file_path = backup_file_path(file_path)?;
// Make backup of old file
std::fs::rename(file_path, backup_file_path)
.map_err(|error| ask_dracula::Error::new_write_file(file_path.to_owned(), error))?;
// Write updated version of the file
let file_content = format!("{}", project);
std::fs::write(file_path, &file_content)
.map_err(|error| ask_dracula::Error::new_write_file(file_path.to_owned(), error))?;
Ok(())
},
ProofResult::Satisfiable =>
{
println!("conjecture disproven");
Ok(())
},
}
}

73
src/parse.rs

@ -1,18 +1,38 @@
use nom::
{
IResult,
character::complete::multispace0,
sequence::{delimited, pair, terminated},
combinator::map,
sequence::{delimited, pair, preceded, terminated, tuple},
combinator::{map, recognize},
branch::alt,
bytes::complete::tag,
};
use foliage::parse::whitespace0;
pub fn recognize_and_keep<I: Clone + nom::Offset + nom::Slice<std::ops::RangeTo<usize>>, O, E: nom::error::ParseError<I>, F>(parser: F) -> impl Fn(I) -> IResult<I, (I, O), E>
where
F: Fn(I) -> IResult<I, O, E>,
{
move |input: I|
{
let i = input.clone();
match parser(i)
{
Ok((i, result)) =>
{
let index = input.offset(&i);
Ok((i, (input.slice(..index), result)))
},
Err(e) => Err(e),
}
}
}
fn statement_kind(i: &str) -> IResult<&str, crate::project::StatementKind>
{
let foo = delimited
(
multispace0,
whitespace0,
alt
((
map
@ -31,7 +51,7 @@ fn statement_kind(i: &str) -> IResult<&str, crate::project::StatementKind>
|_| crate::project::StatementKind::Conjecture,
),
)),
multispace0,
whitespace0,
)(i);
foo
@ -46,26 +66,35 @@ fn statement(i: &str) -> IResult<&str, (crate::project::StatementKind, foliage::
statement_kind,
foliage::formula,
),
delimited
preceded
(
multispace0,
whitespace0,
tag("."),
multispace0,
),
)(i)
}
fn statement_enclosed_by_whitespace(i: &str) -> IResult<&str, (&str, (&str, (crate::project::StatementKind, foliage::Formula)), &str)>
{
tuple
((
recognize(whitespace0),
recognize_and_keep(statement),
recognize(whitespace0),
))(i)
}
pub fn project(i: &str) -> IResult<&str, crate::Project>
{
let mut statement_input = i.clone();
let mut statements = std::collections::HashMap::new();
let mut blocks = Vec::new();
loop
{
let i_ = statement_input.clone();
match statement(i_)
match statement_enclosed_by_whitespace(i_)
{
Ok((i, (statement_kind, formula))) =>
Ok((i, (whitespace_before, (statement_original_text, (statement_kind, formula)), whitespace_after))) =>
{
// Iteration must always consume input (to prevent infinite loops)
if i == statement_input
@ -73,8 +102,24 @@ pub fn project(i: &str) -> IResult<&str, crate::Project>
return Err(nom::Err::Error(nom::error::ParseError::from_error_kind(statement_input, nom::error::ErrorKind::Many0)));
}
let statements = statements.entry(statement_kind).or_insert_with(Vec::new);
statements.push(formula);
if !whitespace_before.is_empty()
{
blocks.push(crate::project::Block::Whitespace(whitespace_before));
}
let statement = crate::project::Statement
{
kind: statement_kind,
original_text: statement_original_text,
formula,
};
blocks.push(crate::project::Block::Statement(statement));
if !whitespace_after.is_empty()
{
blocks.push(crate::project::Block::Whitespace(whitespace_after));
}
statement_input = i;
},
@ -93,7 +138,7 @@ pub fn project(i: &str) -> IResult<&str, crate::Project>
let project = crate::Project
{
statements,
blocks,
};
Ok((i, project))

17
src/project.rs

@ -6,7 +6,20 @@ pub enum StatementKind
Conjecture,
}
pub struct Project
pub struct Statement<'input>
{
pub statements: std::collections::HashMap<StatementKind, Vec<foliage::Formula>>,
pub kind: StatementKind,
pub original_text: &'input str,
pub formula: foliage::Formula,
}
pub enum Block<'input>
{
Statement(Statement<'input>),
Whitespace(&'input str),
}
pub struct Project<'input>
{
pub blocks: Vec<Block<'input>>,
}

Loading…
Cancel
Save