use super::{
OPERATIONS, Status, Verdict, catalogue, check, kind, operation, read, run, suites, summary,
verdict_of,
};
use crate::{Error, Settings};
fn settings() -> Settings {
Settings::default().deterministic()
}
fn ordinary(text: &str, logic: crate::ordinary::Logic) -> String {
super::ordinary::write_statement(&text.parse().unwrap(), logic).unwrap()
}
fn ran(operation: &str, inputs: &[&str], parameters: &str) -> String {
run(operation, inputs, parameters, &settings(), |_| false)
.unwrap()
.value
}
fn checked(operation: &str, inputs: &[&str], parameters: &str, output: &str) -> super::Check {
check(operation, inputs, parameters, output, &settings(), |_| {
false
})
.unwrap()
}
#[test]
fn the_names_list_every_operation_and_kind_once() {
let names: Vec<&str> = suites()
.iter()
.flat_map(|suite| suite.operations().iter().map(|operation| operation.name))
.collect();
assert_eq!(names, OPERATIONS);
for suite in suites() {
for operation in suite.operations() {
assert!(operation.name.starts_with(&format!("{}.", suite.name())));
for kinds in operation.from {
for name in *kinds {
kind(name).unwrap();
}
}
kind(operation.to).unwrap();
assert!(operation.reads.iter().all(|key| key.starts_with("limits.")
|| ["search", "view", "cut", "lambda"].contains(key)
|| key.starts_with("styles.")));
}
}
let json = serde_json::to_value(catalogue()).unwrap();
assert_eq!(json["suites"].as_array().unwrap().len(), 3);
assert_eq!(
json["suites"][1]["operations"][4]["promise"]["name"],
"same_verdict"
);
assert!(matches!(
operation("ordinary.nothing"),
Err(Error::UnknownName { .. })
));
}
#[test]
fn a_call_with_other_inputs_or_parameters_is_refused() {
let sequent = ordinary("|- a", crate::ordinary::Logic::Classical);
let refused = |inputs: &[&str], parameters: &str| {
run(
"ordinary.translate",
inputs,
parameters,
&settings(),
|_| false,
)
.unwrap_err()
.code()
};
assert_eq!(refused(&[], ""), "invalid_option");
assert_eq!(
refused(&[&sequent], r#"{"by": "kuroda"}"#),
"invalid_option"
);
assert_eq!(refused(&["{}"], ""), "json");
let intuitionistic = ordinary("|- a", crate::ordinary::Logic::Intuitionistic);
assert_eq!(refused(&[&intuitionistic], ""), "invalid_option");
}
#[test]
fn a_translation_keeps_the_verdict_and_its_check_says_so() {
let sequent = ordinary("|- a \\/ ~a", crate::ordinary::Logic::Classical);
let parameters = r#"{"translation": "glivenko"}"#;
let translated = ran("ordinary.translate", &[&sequent], parameters);
let limits = settings().limits;
assert_eq!(
summary("ordinary.sequent", &translated, &limits).unwrap(),
"⊢ ¬¬(a ∨ ¬a)"
);
assert!(translated.contains(r#""logic":"intuitionistic""#));
let check = checked("ordinary.translate", &[&sequent], parameters, &translated);
assert_eq!(check.status, Status::Held);
assert_eq!(check.parts.len(), 2);
assert!(
check
.parts
.iter()
.all(|p| p.verdict == Some(Verdict::Valid))
);
let decided = ran("ordinary.decide", &[&translated], "");
assert_eq!(verdict_of(&decided).unwrap(), Verdict::Valid);
assert_eq!(
checked("ordinary.decide", &[&translated], "", &decided).status,
Status::Held
);
}
#[test]
fn a_sequent_that_is_not_valid_has_a_checked_countermodel() {
let sequent = ordinary("a \\/ b |- a", crate::ordinary::Logic::Intuitionistic);
let decided = ran("ordinary.decide", &[&sequent], r#"{"method": "sat"}"#);
let limits = settings().limits;
assert_eq!(
summary("ordinary.outcome", &decided, &limits).unwrap(),
"Not valid"
);
assert_eq!(
checked("ordinary.decide", &[&sequent], "", &decided).status,
Status::Held
);
#[cfg(feature = "svg")]
{
let drawing = ran("ordinary.draw", &[&decided], "");
read("drawing", &drawing, &limits).unwrap();
assert!(drawing.contains("<svg"));
}
let error = run("ordinary.derivation", &[&decided], "", &settings(), |_| {
false
})
.unwrap_err();
assert_eq!(error.code(), "no_derivation");
}
#[test]
fn an_unknown_names_the_bound_that_ended_it() {
let sequent = ordinary("|- ((a -> b) -> a) -> a", crate::ordinary::Logic::Classical);
let tight = settings().with_limits(settings().limits.with_work(Some(1)));
let produced = run(
"ordinary.decide",
&[&sequent],
r#"{"method": "embedding"}"#,
&tight,
|_| false,
)
.unwrap();
let limit = produced.limit.unwrap();
assert_eq!(limit.setting, Some("limits.work"));
assert_eq!(verdict_of(&produced.value).unwrap(), Verdict::Unknown);
}
#[test]
fn an_interpolant_and_its_halves() {
let sequent = ordinary("a /\\ b |- b \\/ c", crate::ordinary::Logic::Classical);
let interpolant = ran("ordinary.interpolate", &[&sequent], "");
let limits = settings().limits;
assert!(
summary("ordinary.interpolant", &interpolant, &limits)
.unwrap()
.starts_with("Interpolant ")
);
let check = checked("ordinary.interpolate", &[&sequent], "", &interpolant);
assert_eq!(check.status, Status::Held, "{check:?}");
assert_eq!(check.parts.len(), 4);
let second = ran("ordinary.half", &[&interpolant], r#"{"which": "second"}"#);
read("ordinary.sequent", &second, &limits).unwrap();
let session = ran("ordinary.start", &[&second], "");
assert_eq!(
summary("ordinary.session", &session, &limits).unwrap(),
"1 open goal"
);
}
#[test]
fn an_embedding_keeps_the_verdict() {
let sequent = ordinary("a, a -> b |- b", crate::ordinary::Logic::Intuitionistic);
let image = ran("ordinary.embed", &[&sequent], "");
read("linear.sequent", &image, &settings().limits).unwrap();
let check = checked("ordinary.embed", &[&sequent], "", &image);
assert_eq!(check.status, Status::Held);
}
#[test]
fn a_linear_proof_its_net_and_its_certificate() {
let sequent = super::linear::write_statement(
&"|- a * b, ~a, ~b".parse().unwrap(),
crate::linear::Mode::CLASSICAL,
)
.unwrap();
let outcome = ran("linear.prove", &[&sequent], "");
assert_eq!(
checked("linear.prove", &[&sequent], "", &outcome).status,
Status::Held
);
let proof: crate::linear::Proof = super::document(&outcome, &settings().limits).unwrap();
let proof = super::written(&proof).unwrap();
let net = ran("linear.net", &[&proof], "");
assert_eq!(
checked("linear.net", &[&proof], "", &net).status,
Status::Held
);
#[cfg(feature = "rocq")]
{
let certificate = ran("linear.certificate", &[&outcome], "");
assert_eq!(
checked("linear.certificate", &[&outcome], "", &certificate).status,
Status::Outside
);
}
let session = ran("linear.start", &[&sequent], "");
let goal = ran("linear.goal", &[&session], r#"{"goal": 0}"#);
assert_eq!(
summary("linear.sequent", &goal, &settings().limits).unwrap(),
summary("linear.sequent", &sequent, &settings().limits).unwrap()
);
}
#[test]
fn an_intuitionistic_goal_keeps_its_sides() {
let sequent = super::linear::write_statement(
&crate::linear::IllSequent::parse_within("a, a -o b |- b", &settings().limits)
.unwrap()
.into_sequent(),
crate::linear::Mode::INTUITIONISTIC,
)
.unwrap();
let session = ran("linear.start", &[&sequent], "");
let goal = ran("linear.goal", &[&session], r#"{"goal": 0}"#);
let outcome = ran("linear.prove", &[&goal], "");
assert_eq!(verdict_of(&outcome).unwrap(), Verdict::Valid);
}
#[test]
fn a_calculus_given_as_data_starts_a_derivation() {
let session = ran(
"rules.start",
&[crate::rules::LJ, r#"{"goal": "a |- a"}"#],
"",
);
assert_eq!(
summary("rules.session", &session, &settings().limits).unwrap(),
"1 open goal"
);
let sequent = ordinary("a /\\ b |- b", crate::ordinary::Logic::Intuitionistic);
let decided = ran("ordinary.decide", &[&sequent], r#"{"method": "ljt"}"#);
let derivation = ran("ordinary.derivation", &[&decided], "");
let generic = ran("rules.from_ordinary", &[&derivation], "");
assert_eq!(
checked("rules.from_ordinary", &[&derivation], "", &generic).status,
Status::Held
);
}
#[test]
fn a_check_with_a_side_not_decided_is_open() {
let sequent = ordinary("|- a \\/ ~a", crate::ordinary::Logic::Classical);
let parameters = r#"{"translation": "glivenko"}"#;
let translated = ran("ordinary.translate", &[&sequent], parameters);
let tight = settings().with_limits(settings().limits.with_work(Some(1)));
let check = check(
"ordinary.translate",
&[&sequent],
parameters,
&translated,
&tight,
|_| false,
)
.unwrap();
assert_eq!(check.status, Status::Open, "{check:?}");
assert!(check.parts.iter().all(|p| p.status != Status::Failed));
}
#[test]
fn an_interpolant_is_held_to_its_input_and_its_halves() {
let sequent = ordinary("a /\\ b |- b \\/ c", crate::ordinary::Logic::Classical);
let interpolant = ran("ordinary.interpolate", &[&sequent], "");
let mut value: serde_json::Value = serde_json::from_str(&interpolant).unwrap();
let limits = settings().limits;
let mut broken = value.clone();
broken["interpolant"]["first"] =
serde_json::from_str(&ordinary("a |-", crate::ordinary::Logic::Classical)).unwrap();
let broken = broken.to_string();
assert_eq!(
read("ordinary.interpolant", &broken, &limits)
.unwrap_err()
.code(),
"json"
);
let other = ordinary("a /\\ c |- b \\/ c", crate::ordinary::Logic::Classical);
let check = checked("ordinary.interpolate", &[&other], "", &interpolant);
assert_eq!(check.status, Status::Failed);
assert_eq!(check.parts[0].name, "halves");
value["interpolant"]["formula"] = serde_json::json!("c");
let renamed = value.to_string();
assert!(read("ordinary.interpolant", &renamed, &limits).is_err());
}
#[test]
fn a_value_of_another_kind_is_refused() {
let sequent = ordinary("a /\\ b |- b", crate::ordinary::Logic::Intuitionistic);
let decided = ran("ordinary.decide", &[&sequent], r#"{"method": "ljt"}"#);
let derivation = ran("ordinary.derivation", &[&decided], "");
let refused = |operation: &str, input: &str| {
run(operation, &[input], "", &settings(), |_| false)
.unwrap_err()
.code()
};
assert_eq!(refused("ordinary.derivation", &derivation), "json");
assert_eq!(refused("ordinary.term", &decided), "json");
let limits = settings().limits;
assert!(read("ordinary.outcome", r#"{"verdict": "banana"}"#, &limits).is_err());
let linear = super::linear::write_statement(
&"|- ~a, a".parse().unwrap(),
crate::linear::Mode::CLASSICAL,
)
.unwrap();
let outcome = ran("linear.prove", &[&linear], "");
assert_eq!(refused("linear.net", &outcome), "json");
assert!(read("linear.proof", &outcome, &limits).is_err());
}