109 lines
3.3 KiB
Agda
109 lines
3.3 KiB
Agda
{-# OPTIONS --prop #-}
|
||
|
||
open import Agda.Builtin.Nat
|
||
open import Agda.Builtin.Bool
|
||
open import Agda.Primitive using (Level)
|
||
|
||
module FirstOrderLogic (TV : Set) (TV= : TV → TV → Bool) (F : Nat → Set) (R : Nat → Set) where
|
||
|
||
open import PropUtil
|
||
open import ListUtil
|
||
|
||
mutual
|
||
data Args : Nat → Set where
|
||
zero : Args 0
|
||
next : {n : Nat} → Args n → Term → Args (suc n)
|
||
data Term : Set where
|
||
Var : TV → Term
|
||
Fun : {n : Nat} → F n → Args n → Term
|
||
|
||
private
|
||
variable
|
||
n : Nat
|
||
|
||
if : {ℓ : Level} → {T : Set ℓ} → Bool → T → T → T
|
||
if true a b = a
|
||
if false a b = b
|
||
|
||
mutual
|
||
[_/_]ᵗ : Term → TV → Term → Term
|
||
[_/_]ᵃ : Term → TV → Args n → Args n
|
||
[ t / x ]ᵗ (Var x') = if (TV= x x') t (Var x')
|
||
[ t / x ]ᵗ (Fun f A) = Fun f ([ t / x ]ᵃ A)
|
||
[ t / x ]ᵃ zero = zero
|
||
[ t / x ]ᵃ (next A t₁) = next ([ t / x ]ᵃ A) ([ t / x ]ᵗ t₁)
|
||
|
||
-- A ⊂sub B if B can be obtained with finite substitution from A
|
||
data _⊂sub_ : Args n → Args n → Prop where
|
||
zero : {A : Args n} → A ⊂sub A
|
||
next : {A B : Args n} → {t : Term} → {x : TV} → A ⊂sub B → A ⊂sub ([ t / x ]ᵃ B)
|
||
|
||
tran⊂sub : {A B C : Args n} → A ⊂sub B → B ⊂sub C → A ⊂sub C
|
||
tran⊂sub zero h₂ = h₂
|
||
tran⊂sub h₁ zero = h₁
|
||
tran⊂sub h₁ (next h₂) = next (tran⊂sub h₁ h₂)
|
||
|
||
data Form : Set where
|
||
Rel : {n : Nat} → R n → (Args n) → Form
|
||
_⇒_ : Form → Form → Form
|
||
_∧∧_ : Form → Form → Form
|
||
⊤⊤ : Form
|
||
∀∀ : TV → Form → Form
|
||
|
||
infixr 10 _∧∧_
|
||
infixr 8 _⇒_
|
||
|
||
Con = List Form
|
||
|
||
private
|
||
variable
|
||
A : Form
|
||
A' : Form
|
||
B : Form
|
||
B' : Form
|
||
C : Form
|
||
Γ : Con
|
||
Γ' : Con
|
||
Γ'' : Con
|
||
Δ : Con
|
||
Δ' : Con
|
||
x : TV
|
||
t : Term
|
||
|
||
[_/_] : Term → TV → Form → Form
|
||
[ t / x ] (Rel r tz) = Rel r ([ t / x ]ᵃ tz)
|
||
[ t / x ] (A ⇒ A₁) = ([ t / x ] A) ⇒ ([ t / x ] A₁)
|
||
[ t / x ] (A ∧∧ A₁) = ([ t / x ] A) ∧∧ ([ t / x ] A₁)
|
||
[ t / x ] ⊤⊤ = ⊤⊤
|
||
[ t / x ] (∀∀ x₁ A) = if (TV= x x₁) A ([ t / x ] A)
|
||
|
||
mutual
|
||
_∉FVᵗ_ : TV → Term → Prop
|
||
_∉FVᵃ_ : TV → Args n → Prop
|
||
x ∉FVᵗ Var x₁ = if (TV= x x₁) ⊥ ⊤
|
||
x ∉FVᵗ Fun f A = x ∉FVᵃ A
|
||
x ∉FVᵃ zero = ⊤
|
||
x ∉FVᵃ next A t = (x ∉FVᵃ A) ∧ (x ∉FVᵗ t)
|
||
_∉FVᶠ_ : TV → Form → Prop
|
||
x ∉FVᶠ Rel R A = x ∉FVᵃ A
|
||
x ∉FVᶠ (A ⇒ A₁) = x ∉FVᶠ A ∧ x ∉FVᶠ A₁
|
||
x ∉FVᶠ (A ∧∧ A₁) = x ∉FVᶠ A ∧ x ∉FVᶠ A₁
|
||
x ∉FVᶠ ⊤⊤ = ⊤
|
||
x ∉FVᶠ ∀∀ x₁ A = if (TV= x x₁) ⊤ (x ∉FVᶠ A)
|
||
_∉FVᶜ_ : TV → Con → Prop
|
||
x ∉FVᶜ [] = ⊤
|
||
x ∉FVᶜ (A ∷ Γ) = x ∉FVᶠ A ∧ x ∉FVᶜ Γ
|
||
|
||
data _⊢_ : Con → Form → Prop where
|
||
zero : A ∈ Γ → Γ ⊢ A
|
||
lam : (A ∷ Γ) ⊢ B → Γ ⊢ (A ⇒ B)
|
||
app : Γ ⊢ (A ⇒ B) → Γ ⊢ A → Γ ⊢ B
|
||
andi : Γ ⊢ A → Γ ⊢ B → Γ ⊢ A ∧∧ B
|
||
ande₁ : Γ ⊢ A ∧∧ B → Γ ⊢ A
|
||
ande₂ : Γ ⊢ A ∧∧ B → Γ ⊢ B
|
||
true : Γ ⊢ ⊤⊤
|
||
∀-i : x ∉FVᶜ Γ → Γ ⊢ A → Γ ⊢ ∀∀ x A
|
||
∀-e : Γ ⊢ ∀∀ x A → Γ ⊢ [ t / x ] A
|
||
|
||
infix 5 _⊢_
|