Theory Superposition

theory Superposition
  imports
    First_Order_Clause.Nonground_Order_With_Equality
    First_Order_Clause.Nonground_Selection_Function
    First_Order_Clause.Nonground_Typing_With_Equality
    First_Order_Clause.Typed_Tiebreakers
    First_Order_Clause.Infinite_Variables
                          
    Ground_Superposition
begin

section ‹Nonground Layer›

locale type_system =
  context_compatible_term_typing_properties where
  welltyped = welltyped and from_ground_context_map = from_ground_context_map +
  witnessed_nonground_typing where welltyped = welltyped
for
  welltyped :: "('v, 'ty) var_types ⇒ 't ⇒ 'ty ⇒ bool" and
  from_ground_context_map :: "('t⇩G ⇒ 't) ⇒ 'c⇩G ⇒ 'c"

locale superposition_calculus =
  type_system where
  welltyped = welltyped and id_subst = "id_subst :: 'subst" and
  from_ground_context_map = "from_ground_context_map :: ('t⇩G ⇒ 't) ⇒ 'c⇩G ⇒ 'c" +

  context_compatible_nonground_order where less⇩t = less⇩t +

  nonground_selection_function where
  select = select and atom_subst = "(⋅a)" and atom_vars = atom.vars and
  atom_to_ground = atom.to_ground and atom_from_ground = atom.from_ground and
  atom_is_ground = atom.is_ground +

  tiebreakers where tiebreakers = tiebreakers +

  ground_term_context' +

  infinite_variables where
  exists_nonground = term.exists_nonground and variables = "UNIV :: 'v set"
  for
    select :: "'t atom select" and
    less⇩t :: "'t ⇒ 't ⇒ bool" and
    tiebreakers :: "('t⇩G atom, 't atom) tiebreakers" and
    welltyped :: "('v, 'ty) var_types ⇒ 't ⇒ 'ty ⇒ bool"
begin

interpretation term_order_notation .

(* TODO: side condition order *)
inductive eq_resolution :: "('t, 'v, 'ty) typed_clause ⇒ ('t, 'v, 'ty) typed_clause ⇒ bool" where
  eq_resolutionI:
  "D = add_mset l D' ⟹
   l = t !≈ t' ⟹
   C = D' ⋅ μ ⟹
   eq_resolution (𝒱, D) (𝒱, C)"
if
  "type_preserving_on (clause.vars D) 𝒱 μ"
  "term.is_imgu μ {{t, t'}}"
  "select D = {#} ⟹ is_maximal (l ⋅l μ) (D ⋅ μ)"
  "select D ≠ {#} ⟹ is_maximal (l ⋅l μ) (select D ⋅ μ)"

inductive eq_factoring :: "('t, 'v, 'ty) typed_clause ⇒ ('t, 'v, 'ty) typed_clause ⇒ bool" where
  eq_factoringI:
  "D = add_mset l⇩1 (add_mset l⇩2 D') ⟹
   l⇩1 = t⇩1 ≈ t⇩1' ⟹
   l⇩2 = t⇩2 ≈ t⇩2' ⟹
   C = add_mset (t⇩1 ≈ t⇩2') (add_mset (t⇩1' !≈ t⇩2') D') ⋅ μ ⟹
   eq_factoring (𝒱, D) (𝒱, C)"
if
  "select D = {#}"
  "is_maximal (l⇩1 ⋅l μ) (D ⋅ μ)"
  "¬ (t⇩1 ⋅t μ ≼⇩t t⇩1' ⋅t μ)"
  "type_preserving_on (clause.vars D) 𝒱 μ"
  "term.is_imgu μ {{t⇩1, t⇩2}}"

inductive superposition ::
  "('t, 'v, 'ty) typed_clause ⇒
   ('t, 'v, 'ty) typed_clause ⇒
   ('t, 'v, 'ty) typed_clause ⇒ bool" where
  superpositionI:
  "E = add_mset l⇩1 E' ⟹
   D = add_mset l⇩2 D' ⟹
   l⇩1 = 𝒫 (Upair c⇩1⟨t⇩1⟩ t⇩1') ⟹
   l⇩2 = t⇩2 ≈ t⇩2' ⟹
   C = add_mset (𝒫 (Upair (c⇩1 ⋅t⇩c ρ⇩1)⟨t⇩2' ⋅t ρ⇩2⟩ (t⇩1' ⋅t ρ⇩1))) (E' ⋅ ρ⇩1 + D' ⋅ ρ⇩2) ⋅ μ ⟹
   superposition (𝒱⇩2, D) (𝒱⇩1, E) (𝒱⇩3, C)"
if
  "𝒫 ∈ {Pos, Neg}"
  "term.exists_nonground ⟹ infinite_variables_per_type 𝒱⇩1"
  "term.exists_nonground ⟹ infinite_variables_per_type 𝒱⇩2"
  "term.is_renaming ρ⇩1"
  "term.is_renaming ρ⇩2"
  "clause.vars (E ⋅ ρ⇩1) ∩ clause.vars (D ⋅ ρ⇩2) = {}"
  "¬ term.is_Var t⇩1"
  "type_preserving_on (clause.vars (E ⋅ ρ⇩1) ∪ clause.vars (D ⋅ ρ⇩2)) 𝒱⇩3 μ"
  "term.is_imgu μ {{t⇩1 ⋅t ρ⇩1, t⇩2 ⋅t ρ⇩2}}"
  "¬ (E ⋅ ρ⇩1 ⊙ μ ≼⇩c D ⋅ ρ⇩2 ⊙ μ)"
  "¬ (c⇩1⟨t⇩1⟩ ⋅t ρ⇩1 ⊙ μ ≼⇩t t⇩1' ⋅t ρ⇩1 ⊙ μ)"
  "¬ (t⇩2 ⋅t ρ⇩2 ⊙ μ ≼⇩t t⇩2' ⋅t ρ⇩2 ⊙ μ)"
  "𝒫 = Pos ⟹ select E = {#}"
  "𝒫 = Pos ⟹ is_strictly_maximal (l⇩1 ⋅l ρ⇩1 ⊙ μ) (E ⋅ ρ⇩1 ⊙ μ)"
  "𝒫 = Neg ⟹ select E = {#} ⟹ is_maximal (l⇩1 ⋅l ρ⇩1 ⊙ μ) (E ⋅ ρ⇩1 ⊙ μ)"
  "𝒫 = Neg ⟹ select E ≠ {#} ⟹ is_maximal (l⇩1 ⋅l ρ⇩1 ⊙ μ) ((select E) ⋅ ρ⇩1 ⊙ μ)"
  "select D = {#}"
  "is_strictly_maximal (l⇩2 ⋅l ρ⇩2 ⊙ μ) (D ⋅ ρ⇩2 ⊙ μ)"
  "∀x ∈ clause.vars E. 𝒱⇩1 x = 𝒱⇩3 (term.rename ρ⇩1 x)"
  "∀x ∈ clause.vars D. 𝒱⇩2 x = 𝒱⇩3 (term.rename ρ⇩2 x)"
  "type_preserving_on (clause.vars E) 𝒱⇩1 ρ⇩1"
  "type_preserving_on (clause.vars D) 𝒱⇩2 ρ⇩2"
  "clause.weakly_welltyped 𝒱⇩3 C ⟹ literal.weakly_welltyped 𝒱⇩2 l⇩2"

abbreviation eq_factoring_inferences where
  "eq_factoring_inferences ≡ { Infer [D] C | D C. eq_factoring D C }"

abbreviation eq_resolution_inferences where
  "eq_resolution_inferences ≡ { Infer [D] C | D C. eq_resolution D C }"

abbreviation superposition_inferences where
  "superposition_inferences ≡ { Infer [D, E] C | D E C. superposition D E C }"

definition inferences :: "('t, 'v, 'ty) typed_clause inference set" where
  "inferences ≡ superposition_inferences ∪ eq_resolution_inferences ∪ eq_factoring_inferences"

abbreviation bottom⇩F :: "('t, 'v, 'ty) typed_clause set" ("⊥⇩F") where
  "bottom⇩F ≡ {(𝒱, {#}) | 𝒱. term.exists_nonground ⟶ infinite_variables_per_type 𝒱 }"

end

end