mirror of
https://github.com/Z3Prover/z3
synced 2026-06-22 08:30:28 +00:00
143 lines
4.3 KiB
C++
143 lines
4.3 KiB
C++
/*++
|
|
Copyright (c) 2020 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
euf_justification.h
|
|
|
|
Abstract:
|
|
|
|
justification structure for euf
|
|
|
|
Author:
|
|
|
|
Nikolaj Bjorner (nbjorner) 2020-08-23
|
|
|
|
Notes:
|
|
|
|
- congruence closure justifications are given a timestamp so it is easy to sort them.
|
|
See the longer description in euf_proof_checker.cpp
|
|
|
|
--*/
|
|
|
|
#pragma once
|
|
|
|
#include "util/dependency.h"
|
|
|
|
namespace euf {
|
|
|
|
class enode;
|
|
|
|
typedef int theory_var;
|
|
typedef int theory_id;
|
|
const theory_var null_theory_var = -1;
|
|
const theory_id null_theory_id = -1;
|
|
|
|
class justification {
|
|
public:
|
|
typedef stacked_dependency_manager<justification> dependency_manager;
|
|
typedef stacked_dependency_manager<justification>::dependency dependency;
|
|
private:
|
|
enum class kind_t {
|
|
axiom_t,
|
|
congruence_t,
|
|
external_t,
|
|
dependent_t,
|
|
equality_t
|
|
};
|
|
kind_t m_kind;
|
|
union {
|
|
int m_theory_id;
|
|
bool m_comm;
|
|
enode* m_n1;
|
|
};
|
|
union {
|
|
void* m_external;
|
|
uint64_t m_timestamp;
|
|
dependency* m_dependency;
|
|
enode* m_n2;
|
|
};
|
|
|
|
justification(bool comm, uint64_t ts):
|
|
m_kind(kind_t::congruence_t),
|
|
m_comm(comm),
|
|
m_timestamp(ts)
|
|
{}
|
|
|
|
justification(void* ext):
|
|
m_kind(kind_t::external_t),
|
|
m_comm(false),
|
|
m_external(ext)
|
|
{}
|
|
|
|
justification(dependency* dep, int):
|
|
m_kind(kind_t::dependent_t),
|
|
m_comm(false),
|
|
m_dependency(dep)
|
|
{}
|
|
|
|
justification(enode* n1, enode* n2):
|
|
m_kind(kind_t::equality_t),
|
|
m_n1(n1),
|
|
m_n2(n2)
|
|
{}
|
|
|
|
justification(int theory_id):
|
|
m_kind(kind_t::axiom_t),
|
|
m_theory_id(theory_id),
|
|
m_external(nullptr)
|
|
{}
|
|
|
|
public:
|
|
|
|
justification():
|
|
m_kind(kind_t::axiom_t),
|
|
m_theory_id(null_theory_id),
|
|
m_external(nullptr)
|
|
{}
|
|
|
|
static justification axiom(int theory_id) { return justification(theory_id); }
|
|
static justification congruence(bool c, uint64_t ts) { return justification(c, ts); }
|
|
static justification external(void* ext) { return justification(ext); }
|
|
static justification dependent(dependency* d) { return justification(d, 1); }
|
|
static justification equality(enode* a, enode* b) { return justification(a, b); }
|
|
|
|
bool is_axiom() const { return m_kind == kind_t::axiom_t; }
|
|
bool is_external() const { return m_kind == kind_t::external_t; }
|
|
bool is_congruence() const { return m_kind == kind_t::congruence_t; }
|
|
bool is_commutative() const { return m_comm; }
|
|
bool is_dependent() const { return m_kind == kind_t::dependent_t; }
|
|
bool is_equality() const { return m_kind == kind_t::equality_t; }
|
|
dependency* get_dependency() const { SASSERT(is_dependent()); return m_dependency; }
|
|
enode* lhs() const { SASSERT(is_equality()); return m_n1; }
|
|
enode* rhs() const { SASSERT(is_equality()); return m_n2; }
|
|
uint64_t timestamp() const { SASSERT(is_congruence()); return m_timestamp; }
|
|
theory_id get_theory_id() const { SASSERT(is_axiom()); return m_theory_id; }
|
|
template <typename T>
|
|
T* ext() const { SASSERT(is_external()); return static_cast<T*>(m_external); }
|
|
|
|
justification copy(std::function<void*(void*)>& copy_justification) const {
|
|
switch (m_kind) {
|
|
case kind_t::external_t:
|
|
return external(copy_justification(m_external));
|
|
case kind_t::axiom_t:
|
|
return axiom(m_theory_id);
|
|
case kind_t::congruence_t:
|
|
return congruence(m_comm, m_timestamp);
|
|
case kind_t::dependent_t:
|
|
NOT_IMPLEMENTED_YET();
|
|
return dependent(m_dependency);
|
|
default:
|
|
UNREACHABLE();
|
|
return axiom(-1);
|
|
}
|
|
}
|
|
|
|
std::ostream& display(std::ostream& out, std::function<void(std::ostream&, void*)> const& ext) const;
|
|
|
|
};
|
|
|
|
inline std::ostream& operator<<(std::ostream& out, justification const& j) {
|
|
return j.display(out, nullptr);
|
|
}
|
|
}
|