Package list: List types

Information

Files

• Package tarball list-1.105.tgz
• Theory source file list.thy (included in the package tarball)

Defined Type Operator

• Data
  • List
    • list

Defined Constants

• Data
  • List
    • ::
    • @
    • []
    • all
    • any
    • case
    • concat
    • drop
    • filter
    • foldl
    • foldr
    • fromSet
    • head
    • interval
    • last
    • length
    • map
    • member
    • nth
    • nub
    • nubReverse
    • null
    • replicate
    • reverse
    • tail
    • take
    • toSet
    • unzip
    • zip
    • zipWith

Theorems

⊦ null []

⊦ length [] = 0

⊦ concat [] = []

⊦ nubReverse [] = []

⊦ reverse [] = []

⊦ toSet [] = ∅

⊦ map id = id

⊦ ∀l. finite (toSet l)

⊦ ∀p. all p []

⊦ ∀l. all (λx. ⊤) l

⊦ zip [] [] = []

⊦ ∀x. ¬member x []

⊦ ∀p. ¬any p []

⊦ unzip [] = ([], [])

⊦ ∀x. replicate x 0 = []

⊦ ∀m. interval m 0 = []

⊦ ∀l. reverse (reverse l) = l

⊦ ∀l. [] @ l = l

⊦ ∀l. l @ [] = l

⊦ ∀l. drop 0 l = l

⊦ ∀l. take 0 l = []

⊦ ∀f. map f [] = []

⊦ ∀p. filter p [] = []

⊦ ∀l. map (λx. x) l = l

⊦ ∀x. last (x :: []) = x

⊦ ∀l. null l ⇔ l = []

⊦ ∀l. length (reverse l) = length l

⊦ ∀l. nub (nub l) = nub l

⊦ ∀l. nubReverse (nubReverse l) = nubReverse l

⊦ ∀l. toSet (nub l) = toSet l

⊦ ∀l. toSet (nubReverse l) = toSet l

⊦ ∀l. toSet (reverse l) = toSet l

⊦ ∀l. length (nub l) ≤ length l

⊦ ∀l. length (nubReverse l) ≤ length l

⊦ ∀l. size (toSet l) ≤ length l

⊦ ∀l. drop (length l) l = []

⊦ ∀l. take (length l) l = l

⊦ ∀l. case [] (::) l = l

⊦ ∀l. foldr (::) [] l = l

⊦ ∀f. zipWith f [] [] = []

⊦ ∀h t. ¬null (h :: t)

⊦ ∀l. all (λx. ⊥) l ⇔ null l

⊦ ∀l. nub l = reverse (nubReverse (reverse l))

⊦ ∀l. length l = 0 ⇔ null l

⊦ ∀l. toSet l = ∅ ⇔ null l

⊦ ∀l. null (concat l) ⇔ all null l

⊦ ∀x n. length (replicate x n) = n

⊦ ∀h t. ¬(h :: t = [])

⊦ ∀h t. head (h :: t) = h

⊦ ∀h t. tail (h :: t) = t

⊦ ∀b f. case b f [] = b

⊦ ∀m n. length (interval m n) = n

⊦ ∀f b. foldr f b [] = b

⊦ ∀f b. foldl f b [] = b

⊦ ∀l. length l = 0 ⇔ l = []

⊦ ∀l. toSet l = ∅ ⇔ l = []

⊦ ∀l. foldl (flip (::)) [] l = reverse l

⊦ ∀s. finite s ⇒ toSet (fromSet s) = s

⊦ ∀h t. nth (h :: t) 0 = h

⊦ ∀f l. null (map f l) ⇔ null l

⊦ ∀f l. length (map f l) = length l

⊦ ∀p l. length (filter p l) ≤ length l

⊦ ∀s. finite s ⇒ length (fromSet s) = size s

⊦ ∀x n. null (replicate x n) ⇔ n = 0

⊦ ∀h t. length (h :: t) = suc (length t)

⊦ ∀l x. member x l ⇔ x ∈ toSet l

⊦ ∀l x. member x (nub l) ⇔ member x l

⊦ ∀l x. member x (nubReverse l) ⇔ member x l

⊦ ∀l x. member x (reverse l) ⇔ member x l

⊦ ∀l₁ l₂. foldr (::) l₂ l₁ = l₁ @ l₂

⊦ ∀l₁ l₂. drop (length l₁) (l₁ @ l₂) = l₂

⊦ ∀l₁ l₂. take (length l₁) (l₁ @ l₂) = l₁

⊦ ∀l₁ l₂. zip l₁ l₂ = zipWith , l₁ l₂

⊦ ∀l. unzip l = (map fst l, map snd l)

⊦ ∀h t. toSet (h :: t) = insert h (toSet t)

⊦ ∀h t. (h :: []) @ t = h :: t

⊦ ∀h t. concat (h :: t) = h @ concat t

⊦ ∀f l. reverse (map f l) = map f (reverse l)

⊦ ∀f l. toSet (map f l) = image f (toSet l)

⊦ ∀f l. map f l = [] ⇔ l = []

⊦ ∀l. ¬null l ⇒ head l :: tail l = l

⊦ ∀x n. replicate x (suc n) = x :: replicate x n

⊦ ∀h t. take 1 (h :: t) = h :: []

⊦ ∀m n. map suc (interval m n) = interval (suc m) n

⊦ ∀l₁ l₂. null (l₁ @ l₂) ⇔ null l₁ ∧ null l₂

⊦ ∀l₁ l₂. length (l₁ @ l₂) = length l₁ + length l₂

⊦ ∀l₁ l₂. reverse (l₁ @ l₂) = reverse l₂ @ reverse l₁

⊦ ∀l₁ l₂. toSet (l₁ @ l₂) = toSet l₁ ∪ toSet l₂

⊦ ∀l₁ l₂. foldl (flip (::)) l₂ l₁ = reverse l₁ @ l₂

⊦ ∀f g. map f ∘ map g = map (f ∘ g)

⊦ ∀l. l = [] ∨ ∃h t. l = h :: t

⊦ ∀p l. ¬all p l ⇔ any (λx. ¬p x) l

⊦ ∀p l. ¬any p l ⇔ all (λx. ¬p x) l

⊦ ∀p l. ¬all (λx. ¬p x) l ⇔ any p l

⊦ ∀p l. ¬any (λx. ¬p x) l ⇔ all p l

⊦ ∀h t. last (h :: t) = if null t then h else last t

⊦ ∀h t. reverse (h :: t) = reverse t @ h :: []

⊦ ∀m n. interval m (suc n) = m :: interval (suc m) n

⊦ ∀n l. n ≤ length l ⇒ length (take n l) = n

⊦ ∀l k. foldl (λn x. suc n) k l = length l + k

⊦ ∀l k. foldr (λx n. suc n) k l = length l + k

⊦ ∀s. finite s ⇒ ∀x. member x (fromSet s) ⇔ x ∈ s

⊦ ∀l. ¬null l ⇒ length (tail l) = length l - 1

⊦ ∀f x n. map f (replicate x n) = replicate (f x) n

⊦ ∀p l. (∀x. member x l ⇒ p x) ⇔ all p l

⊦ ∀p l. (∃x. member x l ∧ p x) ⇔ any p l

⊦ ∀l₁ l₂. last (l₁ @ l₂) = if null l₂ then last l₁ else last l₂

⊦ ∀x₁ x₂ l. last (x₁ :: x₂ :: l) = last (x₂ :: l)

⊦ ∀x n i. i < n ⇒ nth (replicate x n) i = x

⊦ ∀h t l. last (l @ h :: t) = last (h :: t)

⊦ ∀l h t. (h :: t) @ l = h :: t @ l

⊦ ∀l₁ l₂ l₃. l₁ @ l₂ @ l₃ = (l₁ @ l₂) @ l₃

⊦ ∀l l₁ l₂. l @ l₁ = l @ l₂ ⇔ l₁ = l₂

⊦ ∀l l₁ l₂. l₁ @ l = l₂ @ l ⇔ l₁ = l₂

⊦ ∀l l₁ l₂. l @ l₁ = l @ l₂ ⇒ l₁ = l₂

⊦ ∀l l₁ l₂. l₁ @ l = l₂ @ l ⇒ l₁ = l₂

⊦ ∀l. ¬null l ⇒ nth l (length l - 1) = last l

⊦ ∀p l. all p l ⇔ ∀x. x ∈ toSet l ⇒ p x

⊦ ∀p l. any p l ⇔ ∃x. x ∈ toSet l ∧ p x

⊦ ∀f g l. map (f ∘ g) l = map f (map g l)

⊦ ∀p f l. all p (map f l) ⇔ all (p ∘ f) l

⊦ ∀p f l. any p (map f l) ⇔ any (p ∘ f) l

⊦ ∀f b l. foldr f b (reverse l) = foldl (flip f) b l

⊦ ∀f b l. foldl f b l = foldr (flip f) b (reverse l)

⊦ ∀f b l. foldl f b (reverse l) = foldr (flip f) b l

⊦ ∀x y. zip (x :: []) (y :: []) = (x, y) :: []

⊦ ∀x n. toSet (replicate x n) = if n = 0 then ∅ else insert x ∅

⊦ ∀b f h t. case b f (h :: t) = f h t

⊦ ∀l₁ l₂. l₁ @ l₂ = [] ⇔ l₁ = [] ∧ l₂ = []

⊦ ∀xs ys. length xs = length ys ⇒ map fst (zip xs ys) = xs

⊦ ∀xs ys. length xs = length ys ⇒ map snd (zip xs ys) = ys

⊦ ∀s. finite s ⇒ toSet (fromSet s) = s ∧ length (fromSet s) = size s

⊦ ∀f h t. map f (h :: t) = f h :: map f t

⊦ ∀p h t. all p (h :: t) ⇔ p h ∧ all p t

⊦ ∀p h t. any p (h :: t) ⇔ p h ∨ any p t

⊦ ∀p l x. member x (filter p l) ⇔ member x l ∧ p x

⊦ ∀p l. (∀x. all (p x) l) ⇔ all (λy. ∀x. p x y) l

⊦ ∀p l. (∃x. any (p x) l) ⇔ any (λy. ∃x. p x y) l

⊦ ∀n l. n ≤ length l ⇒ length (drop n l) = length l - n

⊦ ∀n l. n ≤ length l ⇒ n + length (drop n l) = length l

⊦ ∀n l. n ≤ length l ⇒ take n l @ drop n l = l

⊦ ∀l xs. unzip l = (xs, []) ⇔ l = [] ∧ xs = []

⊦ ∀l ys. unzip l = ([], ys) ⇔ l = [] ∧ ys = []

⊦ ∀x h t. member x (h :: t) ⇔ x = h ∨ member x t

⊦ ∀x m n. replicate x (m + n) = replicate x m @ replicate x n

⊦ ∀m n x. m ≤ n ⇒ take m (replicate x n) = replicate x m

⊦ ∀m n i. i < n ⇒ nth (interval m n) i = m + i

⊦ ∀l₁ l₂ x. member x (l₁ @ l₂) ⇔ member x l₁ ∨ member x l₂

⊦ ∀f l₁ l₂. map f (l₁ @ l₂) = map f l₁ @ map f l₂

⊦ ∀f. (∀ys. ∃xs. map f xs = ys) ⇔ ∀y. ∃x. f x = y

⊦ ∀p l₁ l₂. all p (l₁ @ l₂) ⇔ all p l₁ ∧ all p l₂

⊦ ∀p l₁ l₂. any p (l₁ @ l₂) ⇔ any p l₁ ∨ any p l₂

⊦ ∀p l₁ l₂. filter p (l₁ @ l₂) = filter p l₁ @ filter p l₂

⊦ ∀p l. all p l ⇔ ∀i. i < length l ⇒ p (nth l i)

⊦ ∀p l. any p l ⇔ ∃i. i < length l ∧ p (nth l i)

⊦ ∀p f l. filter p (map f l) = map f (filter (p ∘ f) l)

⊦ ∀h t.
    nubReverse (h :: t) =
    if member h t then nubReverse t else h :: nubReverse t

⊦ ∀p q l. all p (filter q l) ⇔ all (λx. q x ⇒ p x) l

⊦ ∀p q l. any p (filter q l) ⇔ any (λx. q x ∧ p x) l

⊦ ∀x n y. member y (replicate x n) ⇔ y = x ∧ ¬(n = 0)

⊦ ∀l x. member x l ⇔ ∃i. i < length l ∧ x = nth l i

⊦ ∀l. toSet l = image (nth l) { i. i | i < length l }

⊦ ∀f x y. zipWith f (x :: []) (y :: []) = f x y :: []

⊦ ∀p. p [] ∧ (∀h t. p t ⇒ p (h :: t)) ⇒ ∀l. p l

⊦ ∀f b h t. foldr f b (h :: t) = f h (foldr f b t)

⊦ ∀f b h t. foldl f b (h :: t) = foldl f (f b h) t

⊦ ∀h t n. n < length t ⇒ nth (h :: t) (suc n) = nth t n

⊦ ∀n h t. n ≤ length t ⇒ drop (suc n) (h :: t) = drop n t

⊦ ∀m n x. m ≤ n ⇒ drop m (replicate x n) = replicate x (n - m)

⊦ ∀f l i. i < length l ⇒ nth (map f l) i = f (nth l i)

⊦ ∀f l y. member y (map f l) ⇔ ∃x. y = f x ∧ member x l

⊦ ∀f g l. all (λx. f x = g x) l ⇒ map f l = map g l

⊦ ∀p q l. all (λx. p x ∧ q x) l ⇔ all p l ∧ all q l

⊦ ∀p q l. all (λx. p x ⇒ q x) l ∧ all p l ⇒ all q l

⊦ ∀f b l₁ l₂. foldr f b (l₁ @ l₂) = foldr f (foldr f b l₂) l₁

⊦ ∀f b l₁ l₂. foldl f b (l₁ @ l₂) = foldl f (foldl f b l₁) l₂

⊦ ∀l₁ l₂ n. length l₁ = n ∧ length l₂ = n ⇒ length (zip l₁ l₂) = n

⊦ ∀h₁ h₂ t₁ t₂. h₁ :: t₁ = h₂ :: t₂ ⇔ h₁ = h₂ ∧ t₁ = t₂

⊦ ∀p l. toSet (filter p l) = toSet l \ { x. x | ¬p x }

⊦ ∀n h t. n ≤ length t ⇒ take (suc n) (h :: t) = h :: take n t

⊦ ∀p h t. filter p (h :: t) = if p h then h :: filter p t else filter p t

⊦ ∀x l. member x l ⇔ ∃l₁ l₂. ¬member x l₁ ∧ l = l₁ @ x :: l₂

⊦ ∀l n. length l = suc n ⇔ ∃h t. l = h :: t ∧ length t = n

⊦ ∀b f. ∃fn. fn [] = b ∧ ∀h t. fn (h :: t) = f h t (fn t)

⊦ ∀m n l. m + n ≤ length l ⇒ drop (m + n) l = drop m (drop n l)

⊦ ∀n l i. n + i < length l ⇒ nth (drop n l) i = nth l (n + i)

⊦ ∀n l i. n ≤ length l ∧ i < n ⇒ nth (take n l) i = nth l i

⊦ ∀l xs ys. unzip l = (xs, ys) ⇔ length xs = length ys ∧ l = zip xs ys

⊦ ∀l₁ l1' l₂ l2'. length l₁ = length l1' ∧ l₁ @ l₂ = l1' @ l2' ⇒ l₁ = l1'

⊦ ∀l₁ l1' l₂ l2'. length l₂ = length l2' ∧ l₁ @ l₂ = l1' @ l2' ⇒ l₂ = l2'

⊦ ∀p q l. (∀x. member x l ∧ p x ⇒ q x) ∧ all p l ⇒ all q l

⊦ ∀p q l. (∀x. member x l ∧ p x ⇒ q x) ∧ any p l ⇒ any q l

⊦ ∀f l₁ l₂ n. length l₁ = n ∧ length l₂ = n ⇒ length (zipWith f l₁ l₂) = n

⊦ ∀m n l. m + n ≤ length l ⇒ take (m + n) l = take m l @ take n (drop m l)

⊦ ∀l₁ l₂.
    length l₁ = length l₂ ∧ (∀i. i < length l₁ ⇒ nth l₁ i = nth l₂ i) ⇒
    l₁ = l₂

⊦ ∀x y xs ys.
    length xs = length ys ⇒ zip (x :: xs) (y :: ys) = (x, y) :: zip xs ys

⊦ ∀f. (∀l₁ l₂. map f l₁ = map f l₂ ⇒ l₁ = l₂) ⇔ ∀x y. f x = f y ⇒ x = y

⊦ ∀f h₁ h₂ t₁ t₂.
    length t₁ = length t₂ ⇒
    zipWith f (h₁ :: t₁) (h₂ :: t₂) = f h₁ h₂ :: zipWith f t₁ t₂

⊦ unzip = foldr (λ(x, y) (xs, ys). (x :: xs, y :: ys)) ([], [])

⊦ ∀l₁ l₂ k.
    k < length l₁ + length l₂ ⇒
    nth (l₁ @ l₂) k =
    if k < length l₁ then nth l₁ k else nth l₂ (k - length l₁)

⊦ ∀x₁ x₂ y₁ y₂.
    length x₁ = length y₁ ∧ length x₂ = length y₂ ⇒
    zip (x₁ @ x₂) (y₁ @ y₂) = zip x₁ y₁ @ zip x₂ y₂

⊦ ∀l₁ l₂ n i.
    length l₁ = n ∧ length l₂ = n ∧ i < n ⇒
    nth (zip l₁ l₂) i = (nth l₁ i, nth l₂ i)

⊦ ∀h x y t xs ys.
    unzip (h :: t) = (x :: xs, y :: ys) ⇔ h = (x, y) ∧ unzip t = (xs, ys)

⊦ ∀n l i.
    n ≤ length l ∧ i < length l ⇒
    nth l i = if i < n then nth (take n l) i else nth (drop n l) (i - n)

⊦ ∀x n l₁ l₂.
    l₁ @ l₂ = replicate x n ⇔
    replicate x (length l₁) = l₁ ∧ replicate x (length l₂) = l₂ ∧
    length l₁ + length l₂ = n

⊦ ∀f l₁ l₂ n i.
    length l₁ = n ∧ length l₂ = n ∧ i < n ⇒
    nth (zipWith f l₁ l₂) i = f (nth l₁ i) (nth l₂ i)

⊦ ∀f x₁ x₂ y₁ y₂.
    length x₁ = length y₁ ∧ length x₂ = length y₂ ⇒
    zipWith f (x₁ @ x₂) (y₁ @ y₂) = zipWith f x₁ y₁ @ zipWith f x₂ y₂

⊦ ∀g f b l₁ l₂.
    (∀s. g b s = s) ∧ (∀x s₁ s₂. g (f x s₁) s₂ = f x (g s₁ s₂)) ⇒
    foldr f b (l₁ @ l₂) = g (foldr f b l₁) (foldr f b l₂)

⊦ ∀g f b l₁ l₂.
    (∀s. g s b = s) ∧ (∀s₁ s₂ x. g s₁ (f s₂ x) = f (g s₁ s₂) x) ⇒
    foldl f b (l₁ @ l₂) = g (foldl f b l₁) (foldl f b l₂)

External Type Operators

• →
• bool
• Data
  • Pair
    • ×
• Number
  • Natural
    • natural
• Set
  • set

External Constants

• =
• select
• Data
  • Bool
    • ∀
    • ∧
    • ⇒
    • ∃
    • ∃!
    • ∨
    • ¬
    • cond
    • ⊥
    • ⊤
  • Pair
    • ,
    • fst
    • snd
• Function
  • flip
  • id
  • ∘
• Number
  • Natural
    • *
    • +
    • -
    • <
    • ≤
    • ↑
    • bit0
    • bit1
    • even
    • suc
    • zero
• Set
  • ∅
  • \
  • finite
  • fromPredicate
  • image
  • insert
  • ∈
  • size
  • ∪

Assumptions

⊦ ⊤

⊦ finite ∅

⊦ id = λx. x

⊦ ¬⊥ ⇔ ⊤

⊦ ¬⊤ ⇔ ⊥

⊦ bit0 0 = 0

⊦ size ∅ = 0

⊦ ∀t. t ⇒ t

⊦ ∀n. 0 ≤ n

⊦ ∀n. n ≤ n

⊦ ⊥ ⇔ ∀p. p

⊦ fromPredicate (λx. ⊥) = ∅

⊦ ∀x. ¬(x ∈ ∅)

⊦ ∀t. t ∨ ¬t

⊦ ∀m. ¬(m < 0)

⊦ ∀n. ¬(n < n)

⊦ ∀n. 0 < suc n

⊦ ∀n. n < suc n

⊦ ∀n. n ≤ suc n

⊦ (¬) = λp. p ⇒ ⊥

⊦ (∃) = λp. p ((select) p)

⊦ ∀a. ∃!x. x = a

⊦ ∀t. (∀x. t) ⇔ t

⊦ ∀t. (∃x. t) ⇔ t

⊦ ∀t. (λx. t x) = t

⊦ (∀) = λp. p = λx. ⊤

⊦ ∀t. ¬¬t ⇔ t

⊦ ∀t. (⊤ ⇔ t) ⇔ t

⊦ ∀t. (t ⇔ ⊤) ⇔ t

⊦ ∀t. ⊥ ∧ t ⇔ ⊥

⊦ ∀t. ⊤ ∧ t ⇔ t

⊦ ∀t. t ∧ ⊥ ⇔ ⊥

⊦ ∀t. t ∧ ⊤ ⇔ t

⊦ ∀t. ⊥ ⇒ t ⇔ ⊤

⊦ ∀t. ⊤ ⇒ t ⇔ t

⊦ ∀t. t ⇒ ⊤ ⇔ ⊤

⊦ ∀t. ⊥ ∨ t ⇔ t

⊦ ∀t. ⊤ ∨ t ⇔ ⊤

⊦ ∀t. t ∨ ⊥ ⇔ t

⊦ ∀t. t ∨ ⊤ ⇔ ⊤

⊦ ∀n. ¬(suc n = 0)

⊦ ∀n. 0 + n = n

⊦ ∀m. m + 0 = m

⊦ ∀m. m - 0 = m

⊦ ∀n. n - n = 0

⊦ ∀s. ∅ \ s = ∅

⊦ ∀s. ∅ ∪ s = s

⊦ ∀f. image f ∅ = ∅

⊦ ∀f. flip (flip f) = f

⊦ (∘) = λf g x. f (g x)

⊦ flip = λf x y. f y x

⊦ ∀t. (⊥ ⇔ t) ⇔ ¬t

⊦ ∀t. (t ⇔ ⊥) ⇔ ¬t

⊦ ∀t. t ⇒ ⊥ ⇔ ¬t

⊦ ∀n. even (2 * n)

⊦ ∀n. bit1 n = suc (bit0 n)

⊦ ∀m. m ↑ 0 = 1

⊦ ∀m n. m ≤ m + n

⊦ ∀m n. n ≤ m + n

⊦ (⇒) = λp q. p ∧ q ⇔ p

⊦ ∀t. (t ⇔ ⊤) ∨ (t ⇔ ⊥)

⊦ ∀m. suc m = m + 1

⊦ ∀n. even (suc n) ⇔ ¬even n

⊦ ∀m. m ≤ 0 ⇔ m = 0

⊦ ∀n. suc n - 1 = n

⊦ ∀x. (fst x, snd x) = x

⊦ ∀t₁ t₂. (if ⊥ then t₁ else t₂) = t₂

⊦ ∀t₁ t₂. (if ⊤ then t₁ else t₂) = t₁

⊦ ∀x s. ¬(insert x s = ∅)

⊦ ∀p x. p x ⇒ p ((select) p)

⊦ ∀n. bit0 (suc n) = suc (suc (bit0 n))

⊦ ∀f y. (let x ← y in f x) = f y

⊦ ∀x. ∃a b. x = (a, b)

⊦ ∀x y. x = y ⇔ y = x

⊦ ∀x y. x = y ⇒ y = x

⊦ ∀t₁ t₂. t₁ ∧ t₂ ⇔ t₂ ∧ t₁

⊦ ∀t₁ t₂. t₁ ∨ t₂ ⇔ t₂ ∨ t₁

⊦ ∀m n. m + n = n + m

⊦ ∀m n. m + n - m = n

⊦ ∀s x. finite (insert x s) ⇔ finite s

⊦ ∀s t. s ∪ t = t ∪ s

⊦ ∀p x. x ∈ fromPredicate p ⇔ p x

⊦ ∀n. 2 * n = n + n

⊦ ∀m n. ¬(m < n ∧ n ≤ m)

⊦ ∀m n. ¬(m ≤ n ∧ n < m)

⊦ ∀m n. ¬(m < n) ⇔ n ≤ m

⊦ ∀m n. ¬(m ≤ n) ⇔ n < m

⊦ ∀m n. suc m ≤ n ⇔ m < n

⊦ ∀m. m = 0 ∨ ∃n. m = suc n

⊦ ∀s. (∃x. x ∈ s) ⇔ ¬(s = ∅)

⊦ (∧) = λp q. (λf. f p q) = λf. f ⊤ ⊤

⊦ ∀p. ¬(∀x. p x) ⇔ ∃x. ¬p x

⊦ ∀p. ¬(∃x. p x) ⇔ ∀x. ¬p x

⊦ (∃) = λp. ∀q. (∀x. p x ⇒ q) ⇒ q

⊦ ∀x y. x ∈ insert y ∅ ⇔ x = y

⊦ ∀x s. insert x (insert x s) = insert x s

⊦ ∀x s. insert x ∅ ∪ s = insert x s

⊦ ∀t₁ t₂. ¬(t₁ ⇒ t₂) ⇔ t₁ ∧ ¬t₂

⊦ ∀m n. m + suc n = suc (m + n)

⊦ ∀m n. suc m + n = suc (m + n)

⊦ ∀m n. suc m = suc n ⇔ m = n

⊦ ∀m n. suc m < suc n ⇔ m < n

⊦ ∀m n. suc m ≤ suc n ⇔ m ≤ n

⊦ ∀m n. m + n = n ⇔ m = 0

⊦ ∀f g x. (f ∘ g) x = f (g x)

⊦ ∀f x y. flip f x y = f y x

⊦ ∀t₁ t₂. ¬(t₁ ∧ t₂) ⇔ ¬t₁ ∨ ¬t₂

⊦ ∀t₁ t₂. ¬(t₁ ∨ t₂) ⇔ ¬t₁ ∧ ¬t₂

⊦ ∀m n. even (m * n) ⇔ even m ∨ even n

⊦ ∀m n. even (m + n) ⇔ even m ⇔ even n

⊦ ∀m n. m ↑ suc n = m * m ↑ n

⊦ ∀f g. (∀x. f x = g x) ⇔ f = g

⊦ ∀p a. (∃x. a = x ∧ p x) ⇔ p a

⊦ (∨) = λp q. ∀r. (p ⇒ r) ⇒ (q ⇒ r) ⇒ r

⊦ ∀m n. m ≤ n ⇔ m < n ∨ m = n

⊦ ∀m n. m ≤ n ∧ n ≤ m ⇔ m = n

⊦ ∀f. ∃fn. ∀a b. fn (a, b) = f a b

⊦ ∀m n. m < n ⇔ ∃d. n = m + suc d

⊦ ∀p. (∀x y. p x y) ⇔ ∀y x. p x y

⊦ ∀p. (∃x y. p x y) ⇔ ∃y x. p x y

⊦ ∀p q. (∃x. p ∧ q x) ⇔ p ∧ ∃x. q x

⊦ ∀p q. p ∧ (∃x. q x) ⇔ ∃x. p ∧ q x

⊦ ∀p q. p ⇒ (∀x. q x) ⇔ ∀x. p ⇒ q x

⊦ ∀p q r. p ⇒ q ⇒ r ⇔ p ∧ q ⇒ r

⊦ ∀t₁ t₂ t₃. (t₁ ∧ t₂) ∧ t₃ ⇔ t₁ ∧ t₂ ∧ t₃

⊦ ∀m n p. m * (n * p) = m * n * p

⊦ ∀m n p. m + (n + p) = m + n + p

⊦ ∀p m n. m + p = n + p ⇔ m = n

⊦ ∀m n p. m + n ≤ m + p ⇔ n ≤ p

⊦ ∀m n p. m < n ∧ n ≤ p ⇒ m < p

⊦ ∀m n p. m ≤ n ∧ n ≤ p ⇒ m ≤ p