What’s in Main

What’s in Main

Tobias Nipkow December 12, 2021

Abstract

This document lists the main types, functions and syntax provided by theory Main. It is meant as a quick overview of what is available.

For infix operators and their precedences see the final section. The sophisticated class structure is only hinted at. For details see https:

//isabelle.in.tum.de/library/HOL/HOL.

HOL

The basic logic: x = y, True, False, ¬ P, P ∧ Q, P ∨ Q, P −→ Q, ∀x. P,

∃x. P, ∃!x. P, THE x. P.

undefined :: ⁰a default :: ⁰a Syntax

x 6= y ≡ ¬ (x = y) (~=)

P ←→ Q ≡ P = Q

if x then y else z ≡ If x y z

let x = e₁ in e₂ ≡ Let e₁ (λx. e₂)

Orderings

A collection of classes defining basic orderings: preorder, partial order, linear order, dense linear order and wellorder.

(≤) :: ⁰a ⇒ ⁰a ⇒ bool (<=) (<) :: ⁰a ⇒ ⁰a ⇒ bool

Least :: (⁰a ⇒ bool) ⇒ ⁰a Greatest :: (⁰a ⇒ bool) ⇒ ⁰a min :: ⁰a ⇒ ⁰a ⇒ ⁰a max :: ⁰a ⇒ ⁰a ⇒ ⁰a

top :: ⁰a

bot :: ⁰a

mono :: (⁰a ⇒ ⁰b) ⇒ bool strict_mono :: (⁰a ⇒ ⁰b) ⇒ bool Syntax

x ≥ y ≡ y ≤ x (>=)

x > y ≡ y < x

∀x≤y. P ≡ ∀x. x ≤ y −→ P

∃x≤y. P ≡ ∃x. x ≤ y ∧ P Similarly for <, ≥ and >

LEAST x. P ≡ Least (λx. P) GREATEST x. P ≡ Greatest (λx. P)

Lattices

Classes semilattice, lattice, distributive lattice and complete lattice (the lat- ter in theory HOL.Set).

inf :: ⁰a ⇒ ⁰a ⇒ ⁰a sup :: ⁰a ⇒ ⁰a ⇒ ⁰a Inf :: ⁰a set ⇒ ⁰a Sup :: ⁰a set ⇒ ⁰a Syntax

Available via unbundle lattice_syntax.

x v y ≡ x ≤ y x @ y ≡ x < y x u y ≡ inf x y x t y ≡ sup x y

dA ≡ Inf A

FA ≡ Sup A

> ≡ top

⊥ ≡ bot

Set

{} :: ⁰a set

insert :: ⁰a ⇒ ⁰a set ⇒ ⁰a set Collect :: (⁰a ⇒ bool) ⇒ ⁰a set

(∈) :: ⁰a ⇒ ⁰a set ⇒ bool (:) (∪) :: ⁰a set ⇒ ⁰a set ⇒ ⁰a set (Un) (∩) :: ⁰a set ⇒ ⁰a set ⇒ ⁰a set (Int) S :: ⁰a set set ⇒ ⁰a set

T :: ⁰a set set ⇒ ⁰a set Pow :: ⁰a set ⇒ ⁰a set set UNIV :: ⁰a set

(‘) :: (⁰a ⇒ ⁰b) ⇒ ⁰a set ⇒ ⁰b set Ball :: ⁰a set ⇒ (⁰a ⇒ bool) ⇒ bool Bex :: ⁰a set ⇒ (⁰a ⇒ bool) ⇒ bool Syntax

{a₁,. . .,a_n} ≡ insert a₁ (. . . (insert a_n {}). . .)

a ∈/ A ≡ ¬(x ∈ A)

A ⊆ B ≡ A ≤ B

A ⊂ B ≡ A <B

A ⊇ B ≡ B ≤ A

A ⊃ B ≡ B < A

{x. P} ≡ Collect (λx. P)

{t | x₁ . . . x_n. P} ≡ {v. ∃x₁ . . . x_n. v = t ∧ P} Sx∈I. A ≡ S

((λx. A) ‘ I) (UN)

Sx. A ≡ S

((λx. A) ‘ UNIV) Tx∈I. A ≡ T

((λx. A) ‘ I) (INT)

Tx. A ≡ T

((λx. A) ‘ UNIV)

∀x∈A. P ≡ Ball A (λx. P)

∃x∈A. P ≡ Bex A (λx. P)

range f ≡ f ‘ UNIV

Fun

id :: ⁰a ⇒ ⁰a

(◦) ::(⁰a ⇒ ⁰b) ⇒ (⁰c ⇒ ⁰a) ⇒ ⁰c ⇒ ⁰b (o) inj_on ::(⁰a ⇒ ⁰b) ⇒ ⁰a set ⇒ bool

inj ::(⁰a ⇒ ⁰b) ⇒ bool surj ::(⁰a ⇒ ⁰b) ⇒ bool bij ::(⁰a ⇒ ⁰b) ⇒ bool

bij_betw ::(⁰a ⇒ ⁰b) ⇒ ⁰a set ⇒ ⁰b set ⇒ bool fun_upd ::(⁰a ⇒ ⁰b) ⇒ ⁰a ⇒ ⁰b ⇒ ⁰a ⇒ ⁰b Syntax

f(x := y) ≡ fun_upd f x y

f(x₁:=y₁,. . .,x_n:=y_n) ≡ f(x₁:=y₁). . .(x_n:=y_n)

Hilbert_Choice

Hilbert’s selection (ε) operator: SOME x. P.

inv_into :: ⁰a set ⇒ (⁰a ⇒ ⁰b) ⇒ ⁰b ⇒ ⁰a Syntax

inv ≡ inv_into UNIV

Fixed Points

Theory: HOL.Inductive.

Least and greatest fixed points in a complete lattice ⁰a:

lfp :: (⁰a ⇒ ⁰a) ⇒ ⁰a gfp :: (⁰a ⇒ ⁰a) ⇒ ⁰a

Note that in particular sets (⁰a ⇒ bool) are complete lattices.

Sum_Type

Type constructor +.

Inl :: ⁰a ⇒ ⁰a + ⁰b Inr :: ⁰a ⇒ ⁰b + ⁰a

(<+>) :: ⁰a set ⇒ ⁰b set ⇒ (⁰a + ⁰b) set

Product_Type

Types unit and ×.

() ::unit

Pair :: ⁰a ⇒ ⁰b ⇒ ⁰a × ⁰b fst :: ⁰a × ⁰b ⇒ ⁰a snd :: ⁰a × ⁰b ⇒ ⁰b

case_prod ::(⁰a ⇒ ⁰b ⇒ ⁰c) ⇒ ⁰a × ⁰b ⇒ ⁰c curry ::(⁰a × ⁰b ⇒ ⁰c) ⇒ ⁰a ⇒ ⁰b ⇒ ⁰c

Sigma :: ⁰a set ⇒ (⁰a ⇒ ⁰b set) ⇒ (⁰a × ⁰b) set Syntax

(a, b) ≡ Pair a b

λ(x, y). t ≡ case_prod (λx y. t) A × B ≡ Sigma A (λ_. B)

Pairs may be nested. Nesting to the right is printed as a tuple, e.g. (a, b, c) is really (a, (b, c)). Pattern matching with pairs and tuples extends to all binders, e.g. ∀(x, y)∈A. P, {(x, y). P}, etc.

Relation

converse :: (⁰a × ⁰b) set ⇒ (⁰b × ⁰a) set

(O) :: (⁰a × ⁰b) set ⇒ (⁰b × ⁰c) set ⇒ (⁰a × ⁰c) set (‘‘) :: (⁰a × ⁰b) set ⇒ ⁰a set ⇒ ⁰b set

inv_image :: (⁰a × ⁰a) set ⇒ (⁰b ⇒ ⁰a) ⇒ (⁰b × ⁰b) set Id_on :: ⁰a set ⇒ (⁰a × ⁰a) set

Id :: (⁰a × ⁰a) set

Domain :: (⁰a × ⁰b) set ⇒ ⁰a set Range :: (⁰a × ⁰b) set ⇒ ⁰b set Field :: (⁰a × ⁰a) set ⇒ ⁰a set

refl_on :: ⁰a set ⇒ (⁰a × ⁰a) set ⇒ bool refl :: (⁰a × ⁰a) set ⇒ bool

sym :: (⁰a × ⁰a) set ⇒ bool

antisym :: (⁰a × ⁰a) set ⇒ bool trans :: (⁰a × ⁰a) set ⇒ bool irrefl :: (⁰a × ⁰a) set ⇒ bool

total_on :: ⁰a set ⇒ (⁰a × ⁰a) set ⇒ bool total :: (⁰a × ⁰a) set ⇒ bool

Syntax

r⁻¹ ≡ converse r (^-1)

Type synonym ⁰a rel = (⁰a × ⁰a) set

Equiv_Relations

equiv :: ⁰a set ⇒ (⁰a × ⁰a) set ⇒ bool (//) :: ⁰a set ⇒ (⁰a × ⁰a) set ⇒ ⁰a set set congruent :: (⁰a × ⁰a) set ⇒ (⁰a ⇒ ⁰b) ⇒ bool

congruent2 :: (⁰a × ⁰a) set ⇒ (⁰b × ⁰b) set ⇒ (⁰a ⇒ ⁰b ⇒ ⁰c) ⇒ bool Syntax

f respects r ≡ congruent r f f respects2 r ≡ congruent2 r r f

Transitive_Closure

rtrancl ::(⁰a × ⁰a) set ⇒ (⁰a × ⁰a) set trancl ::(⁰a × ⁰a) set ⇒ (⁰a × ⁰a) set reflcl ::(⁰a × ⁰a) set ⇒ (⁰a × ⁰a) set acyclic ::(⁰a × ⁰a) set ⇒ bool

(^^) ::(⁰a × ⁰a) set ⇒ nat ⇒ (⁰a × ⁰a) set Syntax

r^∗ ≡ rtrancl r (^*) r⁺ ≡ trancl r (^+) r⁼ ≡ reflcl r (^=)

Algebra

Theories HOL.Groups, HOL.Rings, HOL.Fields and HOL.Divides define a large collection of classes describing common algebraic structures from semi- groups up to fields. Everything is done in terms of overloaded operators:

0 :: ⁰a 1 :: ⁰a

(+) :: ⁰a ⇒ ⁰a ⇒ ⁰a (−) :: ⁰a ⇒ ⁰a ⇒ ⁰a

uminus :: ⁰a ⇒ ⁰a (-) (∗) :: ⁰a ⇒ ⁰a ⇒ ⁰a

inverse :: ⁰a ⇒ ⁰a (div) :: ⁰a ⇒ ⁰a ⇒ ⁰a abs :: ⁰a ⇒ ⁰a sgn :: ⁰a ⇒ ⁰a

(dvd) :: ⁰a ⇒ ⁰a ⇒ bool (div) :: ⁰a ⇒ ⁰a ⇒ ⁰a (mod) :: ⁰a ⇒ ⁰a ⇒ ⁰a Syntax

|x| ≡ abs x

Nat

datatype nat = 0 | Suc nat

(+) (−) (∗) (^) (div) (mod) (dvd) (≤) (<) min max Min Max

of_nat :: nat ⇒ ⁰a

(^^) :: (⁰a ⇒ ⁰a) ⇒ nat ⇒ ⁰a ⇒ ⁰a

Int

Type int

(+) (−) uminus (∗) (^) (div) (mod) (dvd) (≤) (<) min max Min Max

abs sgn

nat ::int ⇒ nat of_int ::int ⇒ ⁰a

š :: ⁰a set (Ints) Syntax

int ≡ of_nat

Finite_Set

finite :: ⁰a set ⇒ bool card :: ⁰a set ⇒ nat

Finite_Set.fold :: (⁰a ⇒ ⁰b ⇒ ⁰b) ⇒ ⁰b ⇒ ⁰a set ⇒ ⁰b

Lattices_Big

Min :: ⁰a set ⇒ ⁰a Max :: ⁰a set ⇒ ⁰a

arg_min :: (⁰a ⇒ ⁰b) ⇒ (⁰a ⇒ bool) ⇒ ⁰a

is_arg_min :: (⁰a ⇒ ⁰b) ⇒ (⁰a ⇒ bool) ⇒ ⁰a ⇒ bool arg_max :: (⁰a ⇒ ⁰b) ⇒ (⁰a ⇒ bool) ⇒ ⁰a

is_arg_max :: (⁰a ⇒ ⁰b) ⇒ (⁰a ⇒ bool) ⇒ ⁰a ⇒ bool Syntax

ARG_MIN f x. P ≡ arg_min f (λx. P) ARG_MAX f x. P ≡ arg_max f (λx. P)

Groups_Big

sum :: (⁰a ⇒ ⁰b) ⇒ ⁰a set ⇒ ⁰b prod :: (⁰a ⇒ ⁰b) ⇒ ⁰a set ⇒ ⁰b Syntax

P A ≡ sum (λx. x) A (SUM)

Px∈A. t ≡ sum (λx. t) A Px|P. t ≡ P

x | P. t Similarly for Q

instead of P

(PROD)

Wellfounded

wf ::(⁰a × ⁰a) set ⇒ bool Wellfounded.acc ::(⁰a × ⁰a) set ⇒ ⁰a set measure ::(⁰a ⇒ nat) ⇒ (⁰a × ⁰a) set

(<∗lex∗>) ::(⁰a × ⁰a) set ⇒ (⁰b × ⁰b) set ⇒ ((⁰a × ⁰b) × ⁰a × ⁰b) set (<∗mlex∗>) ::(⁰a ⇒ nat) ⇒ (⁰a × ⁰a) set ⇒ (⁰a × ⁰a) set

less_than ::(nat × nat) set pred_nat ::(nat × nat) set

Set_Interval

lessThan :: ⁰a ⇒ ⁰a set atMost :: ⁰a ⇒ ⁰a set greaterThan :: ⁰a ⇒ ⁰a set atLeast :: ⁰a ⇒ ⁰a set greaterThanLessThan :: ⁰a ⇒ ⁰a ⇒ ⁰a set atLeastLessThan :: ⁰a ⇒ ⁰a ⇒ ⁰a set greaterThanAtMost :: ⁰a ⇒ ⁰a ⇒ ⁰a set atLeastAtMost :: ⁰a ⇒ ⁰a ⇒ ⁰a set Syntax

{..<y} ≡ lessThan y {..y} ≡ atMost y

{x<..} ≡ greaterThan x

{x..} ≡ atLeast x

{x<..<y} ≡ greaterThanLessThan x y

{x..<y} ≡ atLeastLessThan x y

{x<..y} ≡ greaterThanAtMost x y

{x..y} ≡ atLeastAtMost x y Si≤n. A ≡ S

i ∈ {..n}. A

Si<n. A ≡ S

i ∈ {..<n}. A Similarly for T

instead of S

Px = a..b. t ≡ sum (λx. t) {a..b}

Px = a..<b. t ≡ sum (λx. t) {a..<b}

Px≤b. t ≡ sum (λx. t) {..b}

Px<b. t ≡ sum (λx. t) {..<b}

Similarly for Q

instead of P

Power

(^) :: ⁰a ⇒ nat ⇒ ⁰a

Option

datatype ⁰a option = None | Some ⁰a the :: ⁰a option ⇒ ⁰a

map_option :: (⁰a ⇒ ⁰b) ⇒ ⁰a option ⇒ ⁰b option set_option :: ⁰a option ⇒ ⁰a set

Option.bind :: ⁰a option ⇒ (⁰a ⇒ ⁰b option) ⇒ ⁰b option

List

datatype ⁰a list = [] | (#) ⁰a (⁰a list) (@) :: ⁰a list ⇒ ⁰a list ⇒ ⁰a list butlast :: ⁰a list ⇒ ⁰a list

concat :: ⁰a list list ⇒ ⁰a list distinct :: ⁰a list ⇒ bool

drop ::nat ⇒ ⁰a list ⇒ ⁰a list

dropWhile ::(⁰a ⇒ bool) ⇒ ⁰a list ⇒ ⁰a list filter ::(⁰a ⇒ bool) ⇒ ⁰a list ⇒ ⁰a list find ::(⁰a ⇒ bool) ⇒ ⁰a list ⇒ ⁰a option fold ::(⁰a ⇒ ⁰b ⇒ ⁰b) ⇒ ⁰a list ⇒ ⁰b ⇒ ⁰b foldr ::(⁰a ⇒ ⁰b ⇒ ⁰b) ⇒ ⁰a list ⇒ ⁰b ⇒ ⁰b foldl ::(⁰a ⇒ ⁰b ⇒ ⁰a) ⇒ ⁰a ⇒ ⁰b list ⇒ ⁰a hd :: ⁰a list ⇒ ⁰a

last :: ⁰a list ⇒ ⁰a length :: ⁰a list ⇒ nat

lenlex ::(⁰a × ⁰a) set ⇒ (⁰a list × ⁰a list) set lex ::(⁰a × ⁰a) set ⇒ (⁰a list × ⁰a list) set

lexn ::(⁰a × ⁰a) set ⇒ nat ⇒ (⁰a list × ⁰a list) set lexord ::(⁰a × ⁰a) set ⇒ (⁰a list × ⁰a list) set

listrel ::(⁰a × ⁰b) set ⇒ (⁰a list × ⁰b list) set listrel1 ::(⁰a × ⁰a) set ⇒ (⁰a list × ⁰a list) set lists :: ⁰a set ⇒ ⁰a list set

listset :: ⁰a set list ⇒ ⁰a list set sum_list :: ⁰a list ⇒ ⁰a

prod_list :: ⁰a list ⇒ ⁰a

list_all2 :: (⁰a ⇒ ⁰b ⇒ bool) ⇒ ⁰a list ⇒ ⁰b list ⇒ bool list_update :: ⁰a list ⇒ nat ⇒ ⁰a ⇒ ⁰a list

map :: (⁰a ⇒ ⁰b) ⇒ ⁰a list ⇒ ⁰b list measures :: (⁰a ⇒ nat) list ⇒ (⁰a × ⁰a) set (!) :: ⁰a list ⇒ nat ⇒ ⁰a

nths :: ⁰a list ⇒ nat set ⇒ ⁰a list remdups :: ⁰a list ⇒ ⁰a list

removeAll :: ⁰a ⇒ ⁰a list ⇒ ⁰a list remove1 :: ⁰a ⇒ ⁰a list ⇒ ⁰a list replicate :: nat ⇒ ⁰a ⇒ ⁰a list rev :: ⁰a list ⇒ ⁰a list

rotate :: nat ⇒ ⁰a list ⇒ ⁰a list rotate1 :: ⁰a list ⇒ ⁰a list

set :: ⁰a list ⇒ ⁰a set

shuffles :: ⁰a list ⇒ ⁰a list ⇒ ⁰a list set sort :: ⁰a list ⇒ ⁰a list

sorted :: ⁰a list ⇒ bool

sorted_wrt :: (⁰a ⇒ ⁰a ⇒ bool) ⇒ ⁰a list ⇒ bool splice :: ⁰a list ⇒ ⁰a list ⇒ ⁰a list

take :: nat ⇒ ⁰a list ⇒ ⁰a list

takeWhile :: (⁰a ⇒ bool) ⇒ ⁰a list ⇒ ⁰a list tl :: ⁰a list ⇒ ⁰a list

upt :: nat ⇒ nat ⇒ nat list upto :: int ⇒ int ⇒ int list

zip :: ⁰a list ⇒ ⁰b list ⇒ (⁰a × ⁰b) list Syntax

[x₁,. . .,x_n] ≡ x₁ #. . . # x_n # []

[m..<n] ≡ upt m n [i..j] ≡ upto i j

xs[n := x] ≡ list_update xs n x

Px←xs. e ≡ listsum (map (λx. e) xs)

Filter input syntax [pat ← e. b], where pat is a tuple pattern, which stands for filter (λpat. b) e.

List comprehension input syntax: [e. q₁, . . ., q_n] where each qualifier q_i is either a generator pat ← e or a guard, i.e. boolean expression.

Map

Maps model partial functions and are often used as finite tables. However, the domain of a map may be infinite.

Map.empty :: ⁰a ⇒ ⁰b option

(++) :: (⁰a ⇒ ⁰b option) ⇒ (⁰a ⇒ ⁰b option) ⇒ ⁰a ⇒ ⁰b option (◦_m) :: (⁰a ⇒ ⁰b option) ⇒ (⁰c ⇒ ⁰a option) ⇒ ⁰c ⇒ ⁰b option (|‘) :: (⁰a ⇒ ⁰b option) ⇒ ⁰a set ⇒ ⁰a ⇒ ⁰b option

dom :: (⁰a ⇒ ⁰b option) ⇒ ⁰a set ran :: (⁰a ⇒ ⁰b option) ⇒ ⁰b set

(⊆m) :: (⁰a ⇒ ⁰b option) ⇒ (⁰a ⇒ ⁰b option) ⇒ bool map_of :: (⁰a × ⁰b) list ⇒ ⁰a ⇒ ⁰b option

map_upds :: (⁰a ⇒ ⁰b option) ⇒ ⁰a list ⇒ ⁰b list ⇒ ⁰a ⇒ ⁰b option Syntax

Map.empty ≡ λ_. None

m(x 7→ y) ≡ m(x:=Some y)

m(x₁7→y₁,. . .,x_n7→y_n) ≡ m(x₁7→y₁). . .(x_n7→y_n)

[x₁7→y₁,. . .,x_n7→y_n] ≡ Map.empty(x₁7→y₁,. . .,x_n7→y_n) m(xs [7→] ys) ≡ map_upds m xs ys

Infix operators in Main

Operator precedence associativity

Meta-logic =⇒ 1 right

≡ 2

Logic ∧ 35 right

∨ 30 right

−→, ←→ 25 right

=,6= 50 left

Orderings ≤, <, ≥, > 50

Sets ⊆, ⊂,⊇, ⊃ 50

∈, ∈/ 50

∩ 70 left

∪ 65 left

Functions and Relations ◦ 55 left

‘ 90 right

O 75 right

‘‘ 90 right

^^ 80 right

Numbers +,− 65 left

∗, / 70 left

div, mod 70 left

^ 80 right

dvd 50

Lists #,@ 65 right

! 100 left