Plan, apply and roll back changes to a production ontology, with a blast radius report and a proof an auditor can re-check.
Rust ai-nativedescription-logicsformal-verificationinfrastructure-as-codeisabelle-languageknowledge-graphleanlean4mcpmcp-serverontologyowlowl2reasoningrustshaclsparqltheorem-proving
import OOCert.InstitutionFol
/-!
# Witnesses: none of these institutions is empty, and the comorphism that does
# not reflect really does not reflect
A satisfaction condition over an empty model class is true and says nothing. A
comorphism between two one-point institutions preserves entailment and proves
nothing. `W3CWitness.lean` and `ConformingWitness.lean` set the standard for this
repository and this file meets it for the institution layer.
Four jobs, in order.
1. **Two distinct models in every institution defined here**, distinguished by a
SENTENCE rather than by a term-level inequality, because a sentence is what
the satisfaction condition and `Entails` are stated over. `Rdf.rl` gets a
third, `herbrand svfWitness`, which is neither the everything-model nor the
nothing-model: a model class with only those two would distinguish no
condition from any other.
2. **Two distinct models of the background theory** the RDF-to-first-order
comorphism translates into, so `rdf_entailment_transfers_to_fol` is not a
statement about the empty class. One of them, `eqStruc`, satisfies the
coherence axioms non-vacuously: its constants all denote the same element, so
the axiom's antecedent FIRES and the conclusion has to be earned.
3. **The preservation-without-reflection pair, proved.** `rdfs9` is an
entailment of `Rdf.rl` and is not an entailment of `Rdf.simple`, so the
comorphism that forgets the OWL 2 RL conditions is not model-expansive.
`Comorphism.lean` says the two theorems are different; this is the
countermodel that makes the difference observable.
4. **The quarantined structure is inhabited.** `simpleFunctorial` discharges
`Institution.Functorial` for `Rdf.simple`, so the four laws left out of
`Institution` were left out because nothing needs them and not because
nothing satisfies them.
A fifth section does the same job for a mismatch that is easy to miss:
`folInst`'s satisfaction is "true under every assignment" and `Fol.Entails` is
assignment-wise. One implication holds and the other is refuted here with a
two-element structure, so nobody reads the institution's `Entails` as
`Fol.Entails`.
A sixth refutes the other easy misreading. `OOCert.Entails`, the relation
`certificate_sound` is about, is NOT entailment in `Rdf.rl`: it quantifies over
strictly fewer interpretations, because `OOCert.Model` carries four conditions
read off the asserted graph that no signature can hold. The implication runs one
way only and `the_checker_entails_more_than_the_institution` is the countermodel
for the other.
-/
namespace OOCert
namespace InstitutionWitness
open Rdf FolInst
/-! ## Vocabulary for the witnesses
Fresh names. `Witness.lean` already binds `tC`, `tR`, `tD`, `tp`, `tx`, `ty` in
this namespace and reusing them would silently couple two files' witnesses. -/
def iA : Term := "<http://ex.org/A>"
def iB : Term := "<http://ex.org/B>"
def iX : Term := "<http://ex.org/x>"
/-- The signature every RDF witness below is stated over: `rdf:type` and
`rdfs:subClassOf` in predicate position. -/
def sigT : Rdf.Sig := [V.type, V.subClassOf]
def senXA : Rdf.Sen sigT := ⟨⟨iX, V.type, iA⟩, List.Mem.head _⟩
def senAB : Rdf.Sen sigT := ⟨⟨iA, V.subClassOf, iB⟩, List.Mem.tail _ (List.Mem.head _)⟩
def senXB : Rdf.Sen sigT := ⟨⟨iX, V.type, iB⟩, List.Mem.head _⟩
/-- A sentence about the `svf` witness graph of `Witness.lean`, used only to
tell that model apart from the other two. -/
def senSvf : Rdf.Sen sigT := ⟨⟨tx, V.type, tR⟩, List.Mem.head _⟩
/-! ## 1. Every institution here has at least two distinct models
The four lemmas below are `Iff.rfl`. They exist so that `decide` has a decidable
proposition to work on: satisfaction in these institutions unfolds to membership
in the witness graph, and stating that once keeps every refutation below a
kernel computation over concrete strings rather than a tactic script. -/
theorem simpleEmpty_sat (φ : Rdf.Sen sigT) :
Rdf.simple.sat (S := sigT) (herbrand []) φ ↔ φ.1 ∈ ([] : List Triple) := Iff.rfl
/-- The everything-model and the nothing-model of `Rdf.simple`, told apart by a
sentence. -/
theorem simple_has_two_distinct_models :
Rdf.simple.sat (S := sigT) saturated senXA ∧
¬ Rdf.simple.sat (S := sigT) (herbrand []) senXA := by
refine ⟨trivial, ?_⟩
rw [simpleEmpty_sat]
decide
theorem simple_models_are_distinct : (saturated : Rdf.simple.Mod sigT) ≠ herbrand [] := by
intro h
exact simple_has_two_distinct_models.2 (h ▸ simple_has_two_distinct_models.1)
/-- A model of `Rdf.rl` is an interpretation together with a proof that it
satisfies `OOCert.Conditions`. All three below take that proof from a model
theorem `Witness.lean` already proves, so nothing is re-derived here. -/
def rlSaturated : Rdf.rl.Mod sigT := ⟨saturated, (saturated_is_a_model []).conds⟩
def rlEmpty : Rdf.rl.Mod sigT := ⟨herbrand [], empty_herbrand_is_a_model.conds⟩
/-- The one that is neither everything nor nothing: the Herbrand model of the
`someValuesFrom` witness graph, which satisfies `svf` non-vacuously. -/
def rlSvf : Rdf.rl.Mod sigT := ⟨herbrand svfWitness, svf_witness_is_a_model.conds⟩
theorem rlEmpty_sat (φ : Rdf.Sen sigT) :
Rdf.rl.sat rlEmpty φ ↔ φ.1 ∈ ([] : List Triple) := Iff.rfl
theorem rlSvf_sat (φ : Rdf.Sen sigT) :
Rdf.rl.sat rlSvf φ ↔ φ.1 ∈ svfWitness := Iff.rfl
theorem rl_has_three_pairwise_distinct_models :
(Rdf.rl.sat rlSaturated senXA ∧ ¬ Rdf.rl.sat rlEmpty senXA) ∧
(Rdf.rl.sat rlSvf senSvf ∧ ¬ Rdf.rl.sat rlEmpty senSvf) ∧
(Rdf.rl.sat rlSaturated senXA ∧ ¬ Rdf.rl.sat rlSvf senXA) := by
refine ⟨⟨trivial, ?_⟩, ⟨?_, ?_⟩, ⟨trivial, ?_⟩⟩
· rw [rlEmpty_sat]; decide
· rw [rlSvf_sat]; decide
· rw [rlEmpty_sat]; decide
· rw [rlSvf_sat]; decide
theorem rl_models_are_pairwise_distinct :
rlSaturated ≠ rlEmpty ∧ rlSvf ≠ rlEmpty ∧ rlSaturated ≠ rlSvf := by
refine ⟨?_, ?_, ?_⟩
· intro h
exact rl_has_three_pairwise_distinct_models.1.2
(h ▸ rl_has_three_pairwise_distinct_models.1.1)
· intro h
exact rl_has_three_pairwise_distinct_models.2.1.2
(h ▸ rl_has_three_pairwise_distinct_models.2.1.1)
· intro h
exact rl_has_three_pairwise_distinct_models.2.2.2
(h ▸ rl_has_three_pairwise_distinct_models.2.2.1)
/-- Two first-order structures. `Fol.Struc.nonempty` is a field, so the carrier
is `Unit` rather than `Empty`: an empty carrier is not a structure and
`Fol/Semantics.lean` says why. -/
def allTrue : Fol.Struc where
Dom := Unit
nonempty := ⟨()⟩
p1 := fun _ _ => True
p2 := fun _ _ _ => True
c := fun _ => ()
def allFalse : Fol.Struc where
Dom := Unit
nonempty := ⟨()⟩
p1 := fun _ _ => False
p2 := fun _ _ _ => False
c := fun _ => ()
/-- A unary atom, open in variable 0. -/
def openP : Fol.Form := .app1 "P" (.var 0)
theorem fol_has_two_distinct_models :
folInst.sat (S := []) allTrue openP ∧ ¬ folInst.sat (S := []) allFalse openP :=
⟨fun _ => trivial, fun h => h (fun _ => ())⟩
theorem fol_models_are_distinct : allTrue ≠ allFalse := by
intro h
exact fol_has_two_distinct_models.2 (h ▸ fol_has_two_distinct_models.1)
/-! ## 2. The background theory has models, and one of them earns them
`rdf_entailment_transfers_to_fol` quantifies over the models of `cohTheory S`.
If that class were empty the theorem would be vacuous, so here are three
structures in it.
`allFalse` satisfies the coherence axiom by having a false antecedent inside the
quantifiers, which is the degenerate way. `eqStruc` is the one that matters: every
constant denotes `true`, so `c q = c p` HOLDS for every pair and the axiom's
inner implication has to be discharged on its merits. It is, because every binary
symbol is interpreted by the same relation. -/
/-- All constants denote one element and every binary symbol means equality. The
coherence axioms fire and are satisfied. -/
def eqStruc : Fol.Struc where
Dom := Bool
nonempty := ⟨true⟩
p1 := fun _ _ => True
p2 := fun _ x y => x = y
c := fun _ => true
theorem allTrue_models_coh (S : Rdf.Sig) :
folInst.Models (S := S) allTrue (cohTheory S).ax := by
rintro f ⟨q, _, p, _, rfl⟩ e
intro _ _ _ _
trivial
theorem allFalse_models_coh (S : Rdf.Sig) :
folInst.Models (S := S) allFalse (cohTheory S).ax := by
rintro f ⟨q, _, p, _, rfl⟩ e
intro _ _ _ h
exact h.elim
/-- The non-degenerate one: the antecedent `c q = c p` is true for every pair,
so this model satisfies the axioms rather than dodging them. -/
theorem eqStruc_models_coh (S : Rdf.Sig) :
folInst.Models (S := S) eqStruc (cohTheory S).ax := by
rintro f ⟨q, _, p, _, rfl⟩ e
intro _ _ _ h
exact h
/-- A closed sentence that tells `eqStruc` apart from `allTrue`: not everything
is related to everything, because `true ≠ false`. -/
def everythingRelated : Fol.Form := .all 0 (.all 1 (.app2 "r" (.var 0) (.var 1)))
theorem coh_theory_has_two_distinct_models :
folInst.sat (S := []) allTrue everythingRelated ∧
¬ folInst.sat (S := []) eqStruc everythingRelated := by
refine ⟨fun _ _ _ => trivial, ?_⟩
intro h
exact Bool.noConfusion (h (fun _ => true) true false)
theorem coh_theory_models_are_distinct : allTrue ≠ eqStruc := by
intro h
exact coh_theory_has_two_distinct_models.2 (h ▸ coh_theory_has_two_distinct_models.1)
/-! ## 3. Preservation without reflection, measured
`rdfs9` — from `x rdf:type A` and `A rdfs:subClassOf B` conclude `x rdf:type B` —
is an entailment of the OWL 2 RL institution, by `sc_sub`. It is NOT an
entailment of the simple RDF institution, because a simple interpretation is
under no obligation to respect `rdfs:subClassOf` at all, and the Herbrand
interpretation of the two premises is the countermodel.
So `forgetConditions` preserves entailment and does not reflect it, and
`Comorphism.reflects_entailment`'s hypothesis is not decoration. -/
/-- The premise set, as a predicate. -/
def Γ9 : Rdf.Sen sigT → Prop := fun ψ => ψ = senXA ∨ ψ = senAB
theorem rdfs9_is_rl_entailed : Rdf.rl.Entails (forgetConditions.image Γ9) senXB := by
intro M hM
have h1 : M.1.sat senXA.1 := hM senXA ⟨senXA, Or.inl rfl, rfl⟩
have h2 : M.1.sat senAB.1 := hM senAB ⟨senAB, Or.inr rfl, rfl⟩
exact M.2.sc_sub (M.1.ι iA) (M.1.ι iB) h2 (M.1.ι iX) h1
/-- The graph of the two premises, read as a Herbrand interpretation. -/
def rdfs9Premises : List Triple := [⟨iX, V.type, iA⟩, ⟨iA, V.subClassOf, iB⟩]
theorem simpleRdfs9_sat (φ : Rdf.Sen sigT) :
Rdf.simple.sat (S := sigT) (herbrand rdfs9Premises) φ ↔ φ.1 ∈ rdfs9Premises := Iff.rfl
theorem rdfs9_is_not_simple_entailed : ¬ Rdf.simple.Entails Γ9 senXB := by
intro h
have hmod : Rdf.simple.Models (S := sigT) (herbrand rdfs9Premises) Γ9 := by
intro ψ hψ
rcases hψ with rfl | rfl
· exact List.Mem.head _
· exact List.Mem.tail _ (List.Mem.head _)
have hno : ¬ Rdf.simple.sat (S := sigT) (herbrand rdfs9Premises) senXB := by
rw [simpleRdfs9_sat]
decide
exact hno (h (herbrand rdfs9Premises) hmod)
/-- **The two theorems of `Comorphism.lean` are different theorems**, and this
is the pair that shows it: the target entails the translation, the source does
not entail the original. -/
theorem preservation_does_not_give_reflection :
Rdf.rl.Entails (forgetConditions.image Γ9) (forgetConditions.senMap senXB) ∧
¬ Rdf.simple.Entails Γ9 senXB :=
⟨rdfs9_is_rl_entailed, rdfs9_is_not_simple_entailed⟩
/-- Consequently the comorphism is not model-expansive. Proved from the pair
above through `Comorphism.reflects_entailment`, so the refutation is of the
HYPOTHESIS and not merely of the conclusion. -/
theorem forgetting_the_conditions_is_not_model_expansive :
¬ forgetConditions.ModelExpansive := fun hexp =>
rdfs9_is_not_simple_entailed (forgetConditions.reflects_entailment hexp rdfs9_is_rl_entailed)
/-! ## 4. The quarantined structure is inhabited
`Institution.Functorial` carries the four laws that `Institution` deliberately
does not. If nothing satisfied them, leaving them out would be hiding a defect
rather than following the weakest-conditions discipline. `Rdf.simple` satisfies
them, and every law is `rfl`: renaming by the identity is the identity on
triples by structure eta, and the two composition laws are function composition
read in the two directions a comorphism reads them. -/
def simpleFunctorial : Institution.Functorial where
toInstitution := Rdf.simple
id := fun _ => { map := fun t => t, into := fun _ h => h }
comp := fun σ τ => { map := fun t => τ.map (σ.map t), into := fun t h => τ.into _ (σ.into t h) }
senMap_id := fun _ _ => rfl
senMap_comp := fun _ _ _ => rfl
modRed_id := fun _ _ => rfl
modRed_comp := fun _ _ _ => rfl
/-! ## 5. `folInst.sat` is validity, and `Fol.Entails` is not
`folInst.sat M f` is "`f` holds under EVERY assignment". `Fol.Entails Γ f`
quantifies the assignment outside the implication. On closed formulas the two
entailment relations agree; on open ones they do not, and the direction that
fails is the one a reader would assume.
`openP` institutionally entails its own universal closure, because a model
satisfying `openP` at every assignment satisfies it at every element. It does not
`Fol.Entails` it, because a single assignment can make `P(x₀)` true while `P`
fails elsewhere. -/
def closedP : Fol.Form := .all 0 openP
theorem institution_entails_the_universal_closure :
folInst.EntailsL (S := []) [openP] closedP := by
intro M hM e d
exact hM openP (List.Mem.head _) (fun _ => d)
/-- The two-element structure that separates the relations. -/
def boolStruc : Fol.Struc where
Dom := Bool
nonempty := ⟨true⟩
p1 := fun _ b => b = true
p2 := fun _ _ _ => True
c := fun _ => true
theorem fol_does_not_entail_the_universal_closure : ¬ Fol.Entails [openP] closedP := by
intro h
have hp : ∀ g ∈ [openP], Fol.Form.holds boolStruc (fun _ => true) g := by
intro g hg
rcases hg with _ | ⟨_, hg⟩
· exact rfl
· cases hg
exact Bool.noConfusion (h boolStruc (fun _ => true) hp false)
/-! ## 6. The checker entails more than the institution does, and here is why
`Rdf.rl_entails_gives_entails` runs one way: an entailment of the OWL 2 RL
institution is an `OOCert.Entails`. The converse used to be recorded as "not
proved and not claimed". It is now refuted.
`OOCert.Model I G` carries four conditions — `int`, `int2`, `uni`, `oneOf` —
stated over `Chain G`, the RDF list read off the ASSERTED GRAPH. A condition
relative to a graph is not a condition on a signature and not a sentence, so
there is nowhere in an institution to put it, and `Rdf.rl.Mod` does not carry it.
`OOCert.Entails` therefore quantifies over strictly fewer interpretations and is
the weaker relation.
`cls-oo` is where the gap is visible. `Witness.lean` proves
`an_enumerated_member_is_entailed`: the members of an `owl:oneOf` list are typed
by the enumerated class, on schema alone. The Herbrand interpretation of those
same premises satisfies every one of the twenty-three `Conditions` fields —
vacuously, because the graph has no reserved predicate in it at all — and it does
NOT type `a` as an `E`. So the same premises and the same conclusion come out
`Entails` and not `Rdf.rl.EntailsL`.
This is a real limit of the institution as defined and not a defect in it. Closing
it means either making the list constructors sentences, which the RDF-Based
Semantics does not do either (its sequences are read off `IEXT`, not off `G`), or
carrying the graph in the signature, which is the theory construction and would
put `Rdf.rl` at `Institution.Th`. Decision 0009 records it as open. -/
/-- The Herbrand interpretation of `ooPremises`, which is `Witness.lean`'s
`owl:oneOf` premise set. Every condition holds vacuously: the graph mentions
`owl:oneOf`, `rdf:first` and `rdf:rest` and no term of `Rdf.Reserved`. -/
theorem oo_premises_conditions : Conditions (herbrand ooPremises) where
sc_sub := fun a b hab => absurd hab (not_mem_pred ooPremises V.subClassOf (by decide) a b)
sc_trans := fun a b _ hab => absurd hab (not_mem_pred ooPremises V.subClassOf (by decide) a b)
sp_sub := fun a b hab => absurd hab (not_mem_pred ooPremises V.subPropertyOf (by decide) a b)
sp_trans := fun a b _ hab =>
absurd hab (not_mem_pred ooPremises V.subPropertyOf (by decide) a b)
dom := fun p c hpc => absurd hpc (not_mem_pred ooPremises V.domain (by decide) p c)
rng := fun p c hpc => absurd hpc (not_mem_pred ooPremises V.range (by decide) p c)
trp := fun p hp => absurd hp (not_typed ooPremises V.transitiveProperty (by decide) p)
symp := fun p hp => absurd hp (not_typed ooPremises V.symmetricProperty (by decide) p)
inv := fun p q hpq => absurd hpq (not_mem_pred ooPremises V.inverseOf (by decide) p q)
same := fun a b hab => absurd hab (not_mem_pred ooPremises V.sameAs (by decide) a b)
eqc := fun a b hab => absurd hab (not_mem_pred ooPremises V.equivalentClass (by decide) a b)
eqp := fun a b hab => absurd hab (not_mem_pred ooPremises V.equivalentProperty (by decide) a b)
svf := fun r p _ hop => absurd hop (not_mem_pred ooPremises V.onProperty (by decide) r p)
avf := fun r p _ hop => absurd hop (not_mem_pred ooPremises V.onProperty (by decide) r p)
hv := fun r p _ hop => absurd hop (not_mem_pred ooPremises V.onProperty (by decide) r p)
svf_sc := fun c1 _ _ y1 _ hsv =>
absurd hsv (not_mem_pred ooPremises V.someValuesFrom (by decide) c1 y1)
svf_sp := fun c1 _ _ _ y hsv =>
absurd hsv (not_mem_pred ooPremises V.someValuesFrom (by decide) c1 y)
avf_sc := fun c1 _ _ y1 _ hav =>
absurd hav (not_mem_pred ooPremises V.allValuesFrom (by decide) c1 y1)
avf_sp := fun c1 _ _ _ y hav =>
absurd hav (not_mem_pred ooPremises V.allValuesFrom (by decide) c1 y)
dom_sc := fun p c1 _ hd => absurd hd (not_mem_pred ooPremises V.domain (by decide) p c1)
dom_sp := fun _ p2 c hd => absurd hd (not_mem_pred ooPremises V.domain (by decide) p2 c)
rng_sc := fun p c1 _ hr => absurd hr (not_mem_pred ooPremises V.range (by decide) p c1)
rng_sp := fun _ p2 c hr => absurd hr (not_mem_pred ooPremises V.range (by decide) p2 c)
/-- The predicates `ooPremises` and its `cls-oo` conclusion use. -/
def sigOO : Rdf.Sig := [V.oneOf, V.first, V.rest, V.type]
def ooSen : List (Rdf.Sen sigOO) :=
[ ⟨⟨tE, V.oneOf, oL0⟩, List.Mem.head _⟩,
⟨⟨oL0, V.first, tA⟩, List.Mem.tail _ (List.Mem.head _)⟩,
⟨⟨oL0, V.rest, oL1⟩, List.Mem.tail _ (List.Mem.tail _ (List.Mem.head _))⟩,
⟨⟨oL1, V.first, tB⟩, List.Mem.tail _ (List.Mem.head _)⟩,
⟨⟨oL1, V.rest, V.nil⟩, List.Mem.tail _ (List.Mem.tail _ (List.Mem.head _))⟩ ]
def ooGoal : Rdf.Sen sigOO :=
⟨⟨tA, V.type, tE⟩, List.Mem.tail _ (List.Mem.tail _ (List.Mem.tail _ (List.Mem.head _)))⟩
/-- The model this refutation runs on. -/
def rlOO : Rdf.rl.Mod sigOO := ⟨herbrand ooPremises, oo_premises_conditions⟩
theorem rlOO_sat (φ : Rdf.Sen sigOO) : Rdf.rl.sat rlOO φ ↔ φ.1 ∈ ooPremises := Iff.rfl
theorem ooSen_are_premises : ∀ ψ ∈ ooSen, ψ.1 ∈ ooPremises := by decide
theorem the_enumeration_is_not_rl_entailed : ¬ Rdf.rl.EntailsL ooSen ooGoal := by
intro h
have hno : ¬ Rdf.rl.sat rlOO ooGoal := by
rw [rlOO_sat]
decide
exact hno (h rlOO (fun ψ hψ => ooSen_are_premises ψ hψ))
/-- **The gap, measured.** The checker's relation holds of this premise set and
this conclusion; the institution's does not. `cls-oo` is what separates them, and
the four graph-relative conditions of `OOCert.Model` are why. -/
theorem the_checker_entails_more_than_the_institution :
Entails ooPremises ooGoal.1 ∧ ¬ Rdf.rl.EntailsL ooSen ooGoal :=
⟨an_enumerated_member_is_entailed, the_enumeration_is_not_rl_entailed⟩
/-! ## The transfer, end to end on a concrete sentence
A premise is entailed by itself in `Rdf.simple`, and the general preservation
theorem turns that into a first-order statement about every model of the
background theory. Small, and it is the whole pipeline: no step of it is written
by hand. -/
def ΓXA : Rdf.Sen sigT → Prop := fun ψ => ψ = senXA
theorem the_translation_of_a_premise_is_first_order_entailed :
∀ M : Fol.Struc, folInst.Models (S := sigT) M (cohTheory sigT).ax →
folInst.Models (S := sigT) M (rdfToFol.image ΓXA) →
folInst.sat (S := sigT) M (rdfToFol.senMap senXA) :=
rdfToFol.preserves_entailment_theoroidal (Institution.entails_of_mem Rdf.simple rfl)
end InstitutionWitness
/-! ## Axiom footprints
Every top-level statement this layer adds, pinned. A `sorry` or a
`native_decide` anywhere in the institution layer fails the build here. -/
/-- info: 'OOCert.Rdf.conditions_reduct' does not depend on any axioms -/
#guard_msgs in
#print axioms Rdf.conditions_reduct
/-- info: 'OOCert.Rdf.rl_entails_gives_entails' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms Rdf.rl_entails_gives_entails
/-- info: 'OOCert.Rdf.simple_entailment_is_rl_entailment' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms Rdf.simple_entailment_is_rl_entailment
/-- info: 'OOCert.FolInst.holds_red' does not depend on any axioms -/
#guard_msgs in
#print axioms FolInst.holds_red
/-- info: 'OOCert.FolInst.fol_entails_gives_institution_entails' does not depend on any axioms -/
#guard_msgs in
#print axioms FolInst.fol_entails_gives_institution_entails
/-- info: 'OOCert.FolInst.rdf_entailment_transfers_to_fol' does not depend on any axioms -/
#guard_msgs in
#print axioms FolInst.rdf_entailment_transfers_to_fol
/-- info: 'OOCert.InstitutionWitness.rl_models_are_pairwise_distinct' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms InstitutionWitness.rl_models_are_pairwise_distinct
/-- info: 'OOCert.InstitutionWitness.fol_models_are_distinct' does not depend on any axioms -/
#guard_msgs in
#print axioms InstitutionWitness.fol_models_are_distinct
/-- info: 'OOCert.InstitutionWitness.preservation_does_not_give_reflection' depends on axioms: [propext] -/
#guard_msgs in
#print axioms InstitutionWitness.preservation_does_not_give_reflection
/--
info: 'OOCert.InstitutionWitness.forgetting_the_conditions_is_not_model_expansive' depends on axioms: [propext]
-/
#guard_msgs in
#print axioms InstitutionWitness.forgetting_the_conditions_is_not_model_expansive
/-- info: 'OOCert.InstitutionWitness.the_checker_entails_more_than_the_institution' depends on axioms: [propext] -/
#guard_msgs in
#print axioms InstitutionWitness.the_checker_entails_more_than_the_institution
/-- info: 'OOCert.InstitutionWitness.coh_theory_models_are_distinct' does not depend on any axioms -/
#guard_msgs in
#print axioms InstitutionWitness.coh_theory_models_are_distinct
/-- info: 'OOCert.InstitutionWitness.fol_does_not_entail_the_universal_closure' does not depend on any axioms -/
#guard_msgs in
#print axioms InstitutionWitness.fol_does_not_entail_the_universal_closure
/--
info: 'OOCert.InstitutionWitness.the_translation_of_a_premise_is_first_order_entailed' does not depend on any axioms
-/
#guard_msgs in
#print axioms InstitutionWitness.the_translation_of_a_premise_is_first_order_entailed
end OOCert