Quellcode-Bibliothek Main_Doc.thy

(*<*)
theory Main_Doc
imports Main
begin

setup ‹
 Document_Output.antiquotation_pretty_source 🍋‹term_type_only› (Args.term -- Args.typ_abbrev)
 (fn ctxt => fn (t, T) =>
 (if fastype_of t = Sign.certify_typ (Proof_Context.theory_of ctxt) T then ()
 else error "term_type_only: type mismatch";
 Syntax.pretty_typ ctxt T))
 ›
setup ‹
 Document_Output.antiquotation_pretty_source 🍋‹expanded_typ› Args.typ
 Syntax.pretty_typ
 ›
(*>*)
text‹

 begin{abstract}
  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›.
 end{abstract}

 section*{HOL}

  basic logic: prop‹x = y›, const‹True›, const‹False›, prop‹¬ P›, prop‹P ∧ Q›,
 prop‹P ∨ Q›, prop‹P ⟶ Q›, prop‹∀x. P›, prop‹∃x. P›, prop‹∃! x. P›,
 term‹THE x. P›.
 🪙

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹HOL.undefined› & k='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹HOL.undefined›\\
 const‹HOL.default› & 'alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹HOL.default›\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
 term‹¬ (x = y)› & @{term[source]"¬ (x = y)"} & ( ontouchend='alert("undefinierte Formatierung verbatim");' >🍋‹~=›)\\
 {term[source]"P ⟷ Q"} & term‹P ⟷ Q› \\
 term‹If x y z› & @{term[source]"If x y z"}\\
 term‹Let e₁ (λx. e₂)› & @{term[source]"Let e₁ (λx. e₂)"}\\
 end{tabular}


 section*{Orderings}

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

 begin{tabular}{@ {} l @ {~::~} l l @ {}}
 const‹Orderings.less_eq› & click='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.less_eq› & (🍋‹<=\›)\\
 const‹Orderings.less› & ck='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.less›\\
 const‹Orderings.Least› & ick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.Least›\\
 const‹Orderings.Greatest› & nclick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.Greatest›\\
 const‹Orderings.min› & k='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.min›\\
 const‹Orderings.max› & k='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.max›\\
 {const[source] top} & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.top›\\
 {const[source] bot} & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Orderings.bot›\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
 {term[source]"x ≥ y"} & term‹x ≥ y› & (🍋‹>=›)\\
 {term[source]"x > y"} & term‹x > y›\\
 term‹∀x≤y. P› & @{term[source]"∀x. x ≤ y ⟶ P"}\\
 term‹∃x≤y. P› & @{term[source]"∃x. x ≤ y ∧ P"}\\
 multicolumn{2}{@ {}l@ {}}{Similarly for $<$, $\ge$ and $>$}\\
 term‹LEAST x. P› & @{term[source]"Least (λx. P)"}\\
 term‹GREATEST x. P› & @{term[source]"Greatest (λx. P)"}\\
 end{tabular}


 section*{Lattices}

  semilattice, lattice, distributive lattice and complete lattice (the
  in theory 🍋‹HOL.Set›).

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Lattices.inf› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Lattices.inf›\\
 const‹Lattices.sup› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Lattices.sup›\\
 const‹Complete_Lattices.Inf› & @{term_type_only Complete_Lattices.Inf "'a set ==> 'a::Inf"}\\
 const‹Complete_Lattices.Sup› & @{term_type_only Complete_Lattices.Sup "'a set ==> 'a::Sup"}\\
 end{tabular}

 subsubsection*{Syntax}

  via 🪙‹unbundle lattice_syntax›.

 begin{supertabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
 {text[source]"x ⊑ y"} & term‹x ≤ y›\\
 {text[source]"x ⊏ y"} & term‹x < y›\\
 {text[source]"x ⊓ y"} & term‹inf x y›\\
 {text[source]"x ⊔ y"} & term‹sup x y›\\
 {text[source]"⊓A"} & term‹Inf A›\\
 {text[source]"⊔A"} & term‹Sup A›\\
 {text[source]"⊤"} & @{term[source] top}\\
 {text[source]"⊥"} & @{term[source] bot}\\
 end{supertabular}


 section*{Set}

 begin{tabular}{@ {} l @ {~::~} l l @ {}}
 const‹Set.empty› & @{term_type_only "Set.empty" "'a set"}\\
 const‹Set.insert› & @{term_type_only insert "'a==>'a set==>'a set"}\\
 const‹Collect› & @{term_type_only Collect "('a==>bool)==>'a set"}\\
 const‹Set.member› & @{term_type_only Set.member "'a==>'a set==>bool"} & (🍋‹:›)\\
 const‹Set.union› & @{term_type_only Set.union "'a set==>'a set ==> 'a set"} & (='undefinierte Formatierung verbatim' onclick='alert("undefinierte Formatierung verbatim");' ontouchend='alert("undefinierte Formatierung verbatim");' >🍋‹Un›)\\
 const‹Set.inter› & @{term_type_only Set.inter "'a set==>'a set ==> 'a set"} & (='undefinierte Formatierung verbatim' onclick='alert("undefinierte Formatierung verbatim");' ontouchend='alert("undefinierte Formatierung verbatim");' >🍋‹Int›)\\
 const‹Union› & @{term_type_only Union "'a set set==>'a set"}\\
 const‹Inter› & @{term_type_only Inter "'a set set==>'a set"}\\
 const‹Pow› & @{term_type_only Pow "'a set ==>'a set set"}\\
 const‹UNIV› & @{term_type_only UNIV "'a set"}\\
 const‹image› & @{term_type_only image "('a==>'b)==>'a set==>'b set"}\\
 const‹Ball› & @{term_type_only Ball "'a set==>('a==>bool)==>bool"}\\
 const‹Bex› & @{term_type_only Bex "'a set==>('a==>bool)==>bool"}\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
 ‹{a₁,…,a_n}› & ‹insert a₁ (… (insert a_n {})…)›\\
 term‹a ∉ A› & @{term[source]"¬(x ∈ A)"}\\
 term‹A ⊆ B› & @{term[source]"A ≤ B"}\\
 term‹A ⊂ B› & @{term[source]"A < B"}\\
 {term[source]"A 🪙 B"} & @{term[source]"B ≤ A"}\\
 {term[source]"A 🪙 B"} & @{term[source]"B < A"}\\
 term‹{x. P}› & @{term[source]"Collect (λx. P)"}\\
 ‹{t | x₁ … x_n. P}› & ‹{v. ∃x₁ … x_n. v = t ∧ P}›\\
 {term[source]"∪x∈I. A"} & @{term[source]"∪((λx. A) ` I)"} & (='color:turquoise'>\texttt{UN})\\
 {term[source]"∪x. A"} & @{term[source]"∪((λx. A) ` UNIV)"}\\
 {term[source]"∩x∈I. A"} & @{term[source]"∩((λx. A) ` I)"} & (='color:turquoise'>\texttt{INT})\\
 {term[source]"∩x. A"} & @{term[source]"∩((λx. A) ` UNIV)"}\\
 term‹∀x∈A. P› & @{term[source]"Ball A (λx. P)"}\\
 term‹∃x∈A. P› & @{term[source]"Bex A (λx. P)"}\\
 term‹range f› & @{term[source]"f ` UNIV"}\\
 end{tabular}


 section*{Fun}

 begin{tabular}{@ {} l @ {~::~} l l @ {}}
 const‹Fun.id› & 🪙‹Fun.id›\\
 const‹Fun.comp› & 🪙‹Fun.comp› & (\texttt{o})\\
 const‹Fun.inj_on› & @{term_type_only Fun.inj_on "('a==>'b)==>'a set==>bool"}\\
 const‹Fun.inj› & 🪙‹Fun.inj›\\
 const‹Fun.surj› & 🪙‹Fun.surj›\\
 const‹Fun.bij› & 🪙‹Fun.bij›\\
 const‹Fun.bij_betw› & @{term_type_only Fun.bij_betw "('a==>'b)==>'a set==>'b set==>bool"}\\
 const‹Fun.monotone_on› & ick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.monotone_on›\\
 const‹Fun.monotone› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.monotone›\\
 const‹Fun.mono_on› & 'alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.mono_on›\\
 const‹Fun.mono› & 🪙‹Fun.mono›\\
 const‹Fun.strict_mono_on› & nclick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.strict_mono_on›\\
 const‹Fun.strict_mono› & ick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.strict_mono›\\
 const‹Fun.antimono› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.antimono›\\
 const‹Fun.fun_upd› & 'alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Fun.fun_upd›\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
 term‹fun_upd f x y› & @{term[source]"fun_upd f x y"}\\
 ‹f(x₁:=y₁,…,x_n:=y_n)› & ‹f(x₁:=y₁)…(x_n:=y_n)›\\
 end{tabular}


 section*{Hilbert\_Choice}

 's selection ($\varepsilon$) operator: term‹SOME x. P›.
 🪙

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Hilbert_Choice.inv_into› & @{term_type_only Hilbert_Choice.inv_into "'a set ==> ('a ==> 'b) ==> ('b ==> 'a)"}
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
 term‹inv› & @{term[source]"inv_into UNIV"}
 end{tabular}

 section*{Fixed Points}

 : 🍋‹HOL.Inductive›.

  and greatest fixed points in a complete lattice 🍋‹'a›:

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Inductive.lfp› & k='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Inductive.lfp›\\
 const‹Inductive.gfp› & k='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Inductive.gfp›\\
 end{tabular}

  that in particular sets (🍋‹'a ==> bool›) are complete lattices.

 section*{Sum\_Type}

  constructor ‹+›.

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Sum_Type.Inl› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Sum_Type.Inl›\\
 const‹Sum_Type.Inr› & ='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Sum_Type.Inr›\\
 const‹Sum_Type.Plus› & @{term_type_only Sum_Type.Plus "'a set==>'b set==>('a+'b)set"}
 end{tabular}


 section*{Product\_Type}

  🍋‹unit› and ‹×›.

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Product_Type.Unity› & nclick='alert("unbekannte/s Formatierung/Symbol typeof");' ontouchend='alert("unbekannte/s Formatierung/Symbol typeof");' >🪙‹Product_Type.Unity›\\
 const‹Pair› & 🪙‹Pair›\\
 const‹fst› & 🪙‹fst›\\
 const‹snd› & 🪙‹snd›\\
 const‹case_prod› & 🪙‹case_prod›\\
 const‹curry› & 🪙‹curry›\\
 const‹Product_Type.Sigma› & @{term_type_only Product_Type.Sigma "'a set==>('a==>'b set)==>('a*'b)set"}\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} ll @ {}}
 term‹Pair a b› & @{term[source]"Pair a b"}\\
 term‹case_prod (λx y. t)› & @{term[source]"case_prod (λx y. t)"}\\
 term‹A × B› & ‹Sigma A (λ🍋‹\_›. B)›
 end{tabular}

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


 section*{Relation}

 begin{supertabular}{@ {} l @ {~::~} l @ {}}
 const‹Relation.converse› & @{term_type_only Relation.converse "('a * 'b)set ==> ('b*'a)set"}\\
 const‹Relation.relcomp› & @{term_type_only Relation.relcomp "('a*'b)set==>('b*'c)set==>('a*'c)set"}\\
 const‹Relation.Image› & @{term_type_only Relation.Image "('a*'b)set==>'a set==>'b set"}\\
 const‹Relation.inv_image› & @{term_type_only Relation.inv_image "('a*'a)set==>('b==>'a)==>('b*'b)set"}\\
 const‹Relation.Id_on› & @{term_type_only Relation.Id_on "'a set==>('a*'a)set"}\\
 const‹Relation.Id› & @{term_type_only Relation.Id "('a*'a)set"}\\
 const‹Relation.Domain› & @{term_type_only Relation.Domain "('a*'b)set==>'a set"}\\
 const‹Relation.Range› & @{term_type_only Relation.Range "('a*'b)set==>'b set"}\\
 const‹Relation.Field› & @{term_type_only Relation.Field "('a*'a)set==>'a set"}\\
 const‹Relation.refl_on› & @{term_type_only Relation.refl_on "'a set==>('a*'a)set==>bool"}\\
 const‹Relation.refl› & @{term_type_only Relation.refl "('a*'a)set==>bool"}\\
 const‹Relation.sym› & @{term_type_only Relation.sym "('a*'a)set==>bool"}\\
 const‹Relation.antisym› & @{term_type_only Relation.antisym "('a*'a)set==>bool"}\\
 const‹Relation.trans› & @{term_type_only Relation.trans "('a*'a)set==>bool"}\\
 const‹Relation.irrefl› & @{term_type_only Relation.irrefl "('a*'a)set==>bool"}\\
 const‹Relation.total_on› & @{term_type_only Relation.total_on "'a set==>('a*'a)set==>bool"}\\
 const‹Relation.total› & @{term_type_only Relation.total "('a*'a)set==>bool"}\\
 end{supertabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
 term‹converse r› & @{term[source]"converse r"} & (🍋‹^-1›)
 end{tabular}
 🪙

 noindent
  synonym \ 🍋‹'a rel› ‹=› @{expanded_typ "'a rel"}

 section*{Equiv\_Relations}

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Equiv_Relations.equiv› & @{term_type_only Equiv_Relations.equiv "'a set ==> ('a*'a)set==>bool"}\\
 const‹Equiv_Relations.quotient› & @{term_type_only Equiv_Relations.quotient "'a set ==> ('a × 'a) set ==> 'a set set"}\\
 const‹Equiv_Relations.congruent› & @{term_type_only Equiv_Relations.congruent "('a*'a)set==>('a==>'b)==>bool"}\\
 const‹Equiv_Relations.congruent2› & @{term_type_only Equiv_Relations.congruent2 "('a*'a)set==>('b*'b)set==>('a==>'b==>'c)==>bool"}\\
 @ {const Equiv_Relations.} & @ {term_type_only Equiv_Relations. ""}\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
 term‹congruent r f› & @{term[source]"congruent r f"}\\
 term‹congruent2 r r f› & @{term[source]"congruent2 r r f"}\\
 end{tabular}


 section*{Transitive\_Closure}

 begin{tabular}{@ {} l @ {~::~} l @ {}}
 const‹Transitive_Closure.rtrancl› & @{term_type_only Transitive_Closure.rtrancl "('a*'a)set==>('a*'a)set"}\\
 const‹Transitive_Closure.trancl› & @{term_type_only Transitive_Closure.trancl "('a*'a)set==>('a*'a)set"}\\
 const‹Transitive_Closure.reflcl› & @{term_type_only Transitive_Closure.reflcl "('a*'a)set==>('a*'a)set"}\\
 const‹Transitive_Closure.acyclic› & @{term_type_only Transitive_Closure.acyclic "('a*'a)set==>bool"}\\
 const‹compower› & @{term_type_only "(^^) :: ('a*'a)set==>nat==>('a*'a)set" "('a*'a)set==>nat==>('a*'a)set"}\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
 term‹rtrancl r› & @{term[source]"rtrancl r"} & (🍋‹^*›)\\
 term‹trancl r› & @{term[source]"trancl r"} & (🍋‹^+›)\\
 term‹reflcl r› & @{term[source]"reflcl r"} & (🍋‹^=›)
 end{tabular}


 section*{Algebra}

  🍋‹HOL.Groups›, 🍋‹HOL.Rings›,
 🍋‹HOL.Euclidean_Rings› and 🍋‹HOL.Fields›
  a large collection of classes describing common algebraic
  from semigroups up to fields. Everything is done in terms of
  operators:

 begin{tabular}{@ {} l @ {~::~} l l @ {}}
 ‹0› & 🪙‹zero›\\
 ‹1› & 🪙‹one›\\
 const‹plus› & 🪙‹plus›\\
 const‹minus› & 🪙‹minus›\\
 const‹uminus› & 🪙‹uminus› & (🍋‹-›)\\
 const‹times› & 🪙‹times›\\
 const‹inverse› & 🪙‹inverse›\\
 const‹divide› & 🪙‹divide›\\
 const‹abs› & 🪙‹abs›\\
 const‹sgn› & 🪙‹sgn›\\
 const‹Rings.dvd› & 🪙‹Rings.dvd›\\
 const‹divide› & 🪙‹divide›\\
 const‹modulo› & 🪙‹modulo›\\
 end{tabular}

 subsubsection*{Syntax}

 begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
 term‹∣x∣› & @{term[source] "abs x"}
 end{tabular}


 section*{Nat}

 🪙‹nat›
 🪙

 begin{tabular}{@ {} lllllll @ {}}
 term‹(+) :: nat ==> nat ==> nat› &
 term‹(-) :: nat ==> nat ==> nat› &
\<^term>\<open>(*) :: nat ==> nat ==> nat› &
term‹(^) :: nat ==> nat ==> nat› &
\<^term>\<open>(div) :: nat \<Rightarrow> nat \<Rightarrow> nat\<close>&
\<^term>\<open>(mod) :: nat \<Rightarrow> nat \<Rightarrow> nat\<close>&
\<^term>\<open>(dvd) :: nat \<Rightarrow> nat \<Rightarrow> bool\<close>\\
\<^term>\<open>(\<le>) :: nat \<Rightarrow> nat \<Rightarrow> bool\<close> &
\<^term>\<open>(<) :: nat \<Rightarrow> nat \<Rightarrow> bool\<close> &
\<^term>\<open>min :: nat \<Rightarrow> nat \<Rightarrow> nat\<close> &
\<^term>\<open>max :: nat \<Rightarrow> nat \<Rightarrow> nat\<close> &
\<^term>\<open>Min :: nat set \<Rightarrow> nat\<close> &
\<^term>\<open>Max :: nat set \<Rightarrow> nat\<close>\\
\end{tabular}

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Nat.of_nat\<close> & \<^typeof>\<open>Nat.of_nat\<close>\\
\<^term>\<open>(^^) :: ('a \<Rightarrow> 'a) \<Rightarrow> nat \<Rightarrow> 'a \<Rightarrow> 'a\<close> &</span>
  @{term_type_only "(^^) :: ('a \<Rightarrow> 'a) \<Rightarrow> nat \<Rightarrow> 'a \<Rightarrow> 'a" "('a \<Rightarrow> 'a) \<Rightarrow> nat \<Rightarrow> 'a \<Rightarrow> 'a"}
\end{tabular}

\section*{Int}

Type \<^typ>\<open>int\<close>
\<^bigskip>

\begin{tabular}{@ {} llllllll @ {}}
\<^term>\<open>(+) :: int \<Rightarrow> int \<Rightarrow> int\<close> &
\<^term>\<open>(-) :: int \<Rightarrow> int \<Rightarrow> int\<close> &
\<^term>\<open>uminus :: int \<Rightarrow> int\<close> &
\<^term>\<open>(*) :: int ==> int ==> int› &
term‹(^) :: int ==> nat ==> int› &
\<^term>\<open>(div) :: int \<Rightarrow> int \<Rightarrow> int\<close>&
\<^term>\<open>(mod) :: int \<Rightarrow> int \<Rightarrow> int\<close>&
\<^term>\<open>(dvd) :: int \<Rightarrow> int \<Rightarrow> bool\<close>\\
\<^term>\<open>(\<le>) :: int \<Rightarrow> int \<Rightarrow> bool\<close> &
\<^term>\<open>(<) :: int \<Rightarrow> int \<Rightarrow> bool\<close> &
\<^term>\<open>min :: int \<Rightarrow> int \<Rightarrow> int\<close> &
\<^term>\<open>max :: int \<Rightarrow> int \<Rightarrow> int\<close> &
\<^term>\<open>Min :: int set \<Rightarrow> int\<close> &
\<^term>\<open>Max :: int set \<Rightarrow> int\<close>\\
\<^term>\<open>abs :: int \<Rightarrow> int\<close> &
\<^term>\<open>sgn :: int \<Rightarrow> int\<close>\\
\end{tabular}

\begin{tabular}{@ {} l @ {~::~} l l @ {}}
\<^const>\<open>Int.nat\<close> & \<^typeof>\<open>Int.nat\<close>\\
\<^const>\<open>Int.of_int\<close> & \<^typeof>\<open>Int.of_int\<close>\\
\<^const>\<open>Int.Ints\<close> & @{term_type_only Int.Ints "'a::ring_1 set"} & (\<^verbatim>\<open>Ints\<close>)
\end{tabular}

\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
\<^term>\<open>of_nat::nat\<Rightarrow>int\<close> & @{term[source]"of_nat"}\\
\end{tabular}


\section*{Finite\_Set}

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Finite_Set.finite\<close> & @{term_type_only Finite_Set.finite "'a set\<Rightarrow>bool"}\\
\<^const>\<open>Finite_Set.card\<close> & @{term_type_only Finite_Set.card "'a set \<Rightarrow> nat"}\\
\<^const>\<open>Finite_Set.fold\<close> & @{term_type_only Finite_Set.fold "('a \<Rightarrow> 'b \<Rightarrow> 'b) \<Rightarrow> 'b \<Rightarrow> 'a set \<Rightarrow> 'b"}\\
\end{tabular}


\section*{Lattices\_Big}

\begin{tabular}{@ {} l @ {~::~} l l @ {}}
\<^const>\<open>Lattices_Big.Min\<close> & \<^typeof>\<open>Lattices_Big.Min\<close>\\
\<^const>\<open>Lattices_Big.Max\<close> & \<^typeof>\<open>Lattices_Big.Max\<close>\\
\<^const>\<open>Lattices_Big.arg_min\<close> & \<^typeof>\<open>Lattices_Big.arg_min\<close>\\
\<^const>\<open>Lattices_Big.is_arg_min\<close> & \<^typeof>\<open>Lattices_Big.is_arg_min\<close>\\
\<^const>\<open>Lattices_Big.arg_max\<close> & \<^typeof>\<open>Lattices_Big.arg_max\<close>\\
\<^const>\<open>Lattices_Big.is_arg_max\<close> & \<^typeof>\<open>Lattices_Big.is_arg_max\<close>\\
\end{tabular}

\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
\<^term>\<open>ARG_MIN f x. P\<close> & @{term[source]"arg_min f (\<lambda>x. P)"}\\
\<^term>\<open>ARG_MAX f x. P\<close> & @{term[source]"arg_max f (\<lambda>x. P)"}\\
\end{tabular}


\section*{Groups\_Big}

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Groups_Big.sum\<close> & @{term_type_only Groups_Big.sum "('a \<Rightarrow> 'b) \<Rightarrow> 'a set \<Rightarrow> 'b::comm_monoid_add"}\\
\<^const>\<open>Groups_Big.prod\<close> & @{term_type_only Groups_Big.prod "('a \<Rightarrow> 'b) \<Rightarrow> 'a set \<Rightarrow> 'b::comm_monoid_mult"}\\
\end{tabular}


\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l l @ {}}
\<^term>\<open>sum (\<lambda>x. x) A\<close> & @{term[source]"sum (\<lambda>x. x) A"} & (\<^verbatim>\<open>SUM\<close>)\\
\<^term>\<open>sum (\<lambda>x. t) A\<close> & @{term[source]"sum (\<lambda>x. t) A"}\\
@{term[source] "\<Sum>x|P. t"} & \<^term>\<open>\<Sum>x|P. t\<close>\\
\multicolumn{2}{@ {}l@ {}}{Similarly for \<open>\<Prod>\<close> instead of \<open>\<Sum>\<close>} &pan> (\<^verbatim>\<open>PROD\<close>)\\
\end{tabular}


\section*{Wellfounded}

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Wellfounded.wf\<close> & @{term_type_only Wellfounded.wf "('a*'a)set\<Rightarrow>bool"}\\
\<^const>\<open>Wellfounded.acc\<close> & @{term_type_only Wellfounded.acc "('a*'a)set\<Rightarrow>'a set"}\\
\<^const>\<open>Wellfounded.measure\<close> & @{term_type_only Wellfounded.measure "('a\<Rightarrow>nat)\<Rightarrow>('a*'a)set"}\\
\<^const>\<open>Wellfounded.lex_prod\<close> & @{term_type_only Wellfounded.lex_prod "('a*'a)set\<Rightarrow>('b*'b)set\<Rightarrow>(('a*'b)*('a*'b))set"}\\
\<^const>\<open>Wellfounded.mlex_prod\<close> & @{term_type_only Wellfounded.mlex_prod "('a\<Rightarrow>nat)\<Rightarrow>('a*'a)set\<Rightarrow>('a*'a)set"}\\
\<^const>\<open>Wellfounded.less_than\<close> & @{term_type_only Wellfounded.less_than "(nat*nat)set"}\\
\<^const>\<open>Wellfounded.pred_nat\<close> & @{term_type_only Wellfounded.pred_nat "(nat*nat)set"}\\
\end{tabular}


\section*{Set\_Interval} % \<^theory>\<open>HOL.Set_Interval\<close>

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>lessThan\<close> & @{term_type_only lessThan "'a::ord \<Rightarrow> 'a set"}\\
\<^const>\<open>atMost\<close> & @{term_type_only atMost "'a::ord \<Rightarrow> 'a set"}\\
\<^const>\<open>greaterThan\<close> & @{term_type_only greaterThan "'a::ord \<Rightarrow> 'a set"}\\
\<^const>\<open>atLeast\<close> & @{term_type_only atLeast "'a::ord \<Rightarrow> 'a set"}\\
\<^const>\<open>greaterThanLessThan\<close> & @{term_type_only greaterThanLessThan "'a::ord \<Rightarrow> 'a \<Rightarrow> 'a set"}\\
\<^const>\<open>atLeastLessThan\<close> & @{term_type_only atLeastLessThan "'a::ord \<Rightarrow> 'a \<Rightarrow> 'a set"}\\
\<^const>\<open>greaterThanAtMost\<close> & @{term_type_only greaterThanAtMost "'a::ord \<Rightarrow> 'a \<Rightarrow> 'a set"}\\
\<^const>\<open>atLeastAtMost\<close> & @{term_type_only atLeastAtMost "'a::ord \<Rightarrow> 'a \<Rightarrow> 'a set"}\\
\end{tabular}

\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
\<^term>\<open>lessThan y\<close> & @{term[source] "lessThan y"}\\
\<^term>\<open>atMost y\<close> & @{term[source] "atMost y"}\\
\<^term>\<open>greaterThan x\<close> & @{term[source] "greaterThan x"}\\
\<^term>\<open>atLeast x\<close> & @{term[source] "atLeast x"}\\
\<^term>\<open>greaterThanLessThan x y\<close> & @{term[source] "greaterThanLessThan x y"}\\
\<^term>\<open>atLeastLessThan x y\<close> & @{term[source] "atLeastLessThan x y"}\\
\<^term>\<open>greaterThanAtMost x y\<close> & @{term[source] "greaterThanAtMost x y"}\\
\<^term>\<open>atLeastAtMost x y\<close> & @{term[source] "atLeastAtMost x y"}\\
@{term[source] "\<Union>i\<le>n. A"} & @{term[source] "\<Union>i \<in> {..n}. A"}\\
@{term[source] "\<Union>i<n. A"} & @{term[source] "\<Union>i \<in> {..<n}. A"}\\
\multicolumn{2}{@ {}l@ {}}{Similarly for \<open>\<Inter>\<close> instead of \<open>\<Union>\<close>}\\
\<^term>\<open>sum (\<lambda>x. t) {a..b}\<close> & @{term[source] "sum (\<lambda>x. t) {a..b}"}\\
\<^term>\<open>sum (\<lambda>x. t) {a..<b}\<close> & @{term[source] "sum (\<lambda>x. t) {a..<b}"}\\
\<^term>\<open>sum (\<lambda>x. t) {..b}\<close> & @{term[source] "sum (\<lambda>x. t) {..b}"}\\
\<^term>\<open>sum (\<lambda>x. t) {..<b}\<close> & @{term[source] "sum (\<lambda>x. t) {..<b}"}\\
\multicolumn{2}{@ {}l@ {}}{Similarly for \<open>\<Prod>\<close> instead of \<open>\<Sum>\<close>}\\
\end{tabular}


\section*{Power}

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Power.power\<close> & \<^typeof>\<open>Power.power\<close>
\end{tabular}


\section*{Option}

\<^datatype>\<open>option\<close>
\<^bigskip>

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Option.the\<close> & \<^typeof>\<open>Option.the\<close>\\
\<^const>\<open>map_option\<close> & @{typ[source]"('a \<Rightarrow> 'b) \<Rightarrow> 'a option \<Rightarrow> 'b option"}\\
\<^const>\<open>set_option\<close> & @{term_type_only set_option "'a option \<Rightarrow> 'a set"}\\
\<^const>\<open>Option.bind\<close> & @{term_type_only Option.bind "'a option \<Rightarrow> ('a \<Rightarrow> 'b option) \<Rightarrow> 'b option"}
\end{tabular}

\section*{List}

\<^datatype>\<open>list\<close>
\<^bigskip>

\begin{supertabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>List.append\<close> & \<^typeof>\<open>List.append\<close>\\
\<^const>\<open>List.butlast\<close> & \<^typeof>\<open>List.butlast\<close>\\
\<^const>\<open>List.concat\<close> & \<^typeof>\<open>List.concat\<close>\\
\<^const>\<open>List.distinct\<close> & \<^typeof>\<open>List.distinct\<close>\\
\<^const>\<open>List.drop\<close> & \<^typeof>\<open>List.drop\<close>\\
\<^const>\<open>List.dropWhile\<close> & \<^typeof>\<open>List.dropWhile\<close>\\
\<^const>\<open>List.filter\<close> & \<^typeof>\<open>List.filter\<close>\\
\<^const>\<open>List.find\<close> & \<^typeof>\<open>List.find\<close>\\
\<^const>\<open>List.fold\<close> & \<^typeof>\<open>List.fold\<close>\\
\<^const>\<open>List.foldr\<close> & \<^typeof>\<open>List.foldr\<close>\\
\<^const>\<open>List.foldl\<close> & \<^typeof>\<open>List.foldl\<close>\\
\<^const>\<open>List.hd\<close> & \<^typeof>\<open>List.hd\<close>\\
\<^const>\<open>List.last\<close> & \<^typeof>\<open>List.last\<close>\\
\<^const>\<open>List.length\<close> & \<^typeof>\<open>List.length\<close>\\
\<^const>\<open>List.lenlex\<close> & @{term_type_only List.lenlex "('a*'a)set\<Rightarrow>('a list * 'a list)set"}\\
\<^const>\<open>List.lex\<close> & @{term_type_only List.lex "('a*'a)set\<Rightarrow>('a list * 'a list)set"}\\
\<^const>\<open>List.lexn\<close> & @{term_type_only List.lexn "('a*'a)set\<Rightarrow>nat\<Rightarrow>('a list * 'a list)set"}\\
\<^const>\<open>List.lexord\<close> & @{term_type_only List.lexord "('a*'a)set\<Rightarrow>('a list * 'a list)set"}\\
\<^const>\<open>List.listrel\<close> & @{term_type_only List.listrel "('a*'b)set\<Rightarrow>('a list * 'b list)set"}\\
\<^const>\<open>List.listrel1\<close> & @{term_type_only List.listrel1 "('a*'a)set\<Rightarrow>('a list * 'a list)set"}\\
\<^const>\<open>List.lists\<close> & @{term_type_only List.lists "'a set\<Rightarrow>'a list set"}\\
\<^const>\<open>List.listset\<close> & @{term_type_only List.listset "'a set list \<Rightarrow> 'a list set"}\\
\<^const>\<open>List.list_all2\<close> & \<^typeof>\<open>List.list_all2\<close>\\
\<^const>\<open>List.list_update\<close> & \<^typeof>\<open>List.list_update\<close>\\
\<^const>\<open>List.map\<close> & \<^typeof>\<open>List.map\<close>\\
\<^const>\<open>List.measures\<close> & @{term_type_only List.measures "('a\<Rightarrow>nat)list\<Rightarrow>('a*'a)set"}\\
\<^const>\<open>List.nth\<close> & \<^typeof>\<open>List.nth\<close>\\
\<^const>\<open>List.nths\<close> & \<^typeof>\<open>List.nths\<close>\\
\<^const>\<open>Groups_List.prod_list\<close> & \<^typeof>\<open>Groups_List.prod_list\<close>\\
\<^const>\<open>List.remdups\<close> & \<^typeof>\<open>List.remdups\<close>\\
\<^const>\<open>List.removeAll\<close> & \<^typeof>\<open>List.removeAll\<close>\\
\<^const>\<open>List.remove1\<close> & \<^typeof>\<open>List.remove1\<close>\\
\<^const>\<open>List.replicate\<close> & \<^typeof>\<open>List.replicate\<close>\\
\<^const>\<open>List.rev\<close> & \<^typeof>\<open>List.rev\<close>\\
\<^const>\<open>List.rotate\<close> & \<^typeof>\<open>List.rotate\<close>\\
\<^const>\<open>List.rotate1\<close> & \<^typeof>\<open>List.rotate1\<close>\\
\<^const>\<open>List.set\<close> & @{term_type_only List.set "'a list \<Rightarrow> 'a set"}\\
\<^const>\<open>List.shuffles\<close> & \<^typeof>\<open>List.shuffles\<close>\\
\<^const>\<open>List.sort\<close> & \<^typeof>\<open>List.sort\<close>\\
\<^const>\<open>List.sorted\<close> & \<^typeof>\<open>List.sorted\<close>\\
\<^const>\<open>List.sorted_wrt\<close> & \<^typeof>\<open>List.sorted_wrt\<close>\\
\<^const>\<open>List.splice\<close> & \<^typeof>\<open>List.splice\<close>\\
\<^const>\<open>Groups_List.sum_list\<close> & \<^typeof>\<open>Groups_List.sum_list\<close>\\
\<^const>\<open>List.take\<close> & \<^typeof>\<open>List.take\<close>\\
\<^const>\<open>List.takeWhile\<close> & \<^typeof>\<open>List.takeWhile\<close>\\
\<^const>\<open>List.tl\<close> & \<^typeof>\<open>List.tl\<close>\\
\<^const>\<open>List.upt\<close> & \<^typeof>\<open>List.upt\<close>\\
\<^const>\<open>List.upto\<close> & \<^typeof>\<open>List.upto\<close>\\
\<^const>\<open>List.zip\<close> & \<^typeof>\<open>List.zip\<close>\\
\end{supertabular}

\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
\<open>[x\<^sub>1,\<dots>,x\<^sub>n]\<close> & \<open>x\<^sub>1 # \<dots> # x\<^sub>n # []\<close>\\
\<^term>\<open>[m..<n]\<close> & @{term[source]"upt m n"}\\
\<^term>\<open>[i..j]\<close> & @{term[source]"upto i j"}\\
\<^term>\<open>xs[n := x]\<close> & @{term[source]"list_update xs n x"}\\
\<^term>\<open>\<Sum>x\<leftarrow>xs. e\<close> & @{term[source]"listsum (map (\<lambda>x. e) xs)"}\\
\end{tabular}
\<^medskip>

Filter input syntax \<open>[pat \<leftarrow> e. b]\<close>, where
\<open>pat\<close> is a tuple pattern, which stands for \<^term>\<open>filter (\<lambda>pat. b) e\<close>.

List comprehension input syntax: \<open>[e. q\<^sub>1, \<dots>, q\<^sub>n]\<close> where each
qualifier \<open>q\<^sub>i\<close> is either a generator \mbox{\<open>pat \<leftarrow> e\<close>} or a
guard, i.e.\ boolean expression.

\section*{Map}

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

\begin{tabular}{@ {} l @ {~::~} l @ {}}
\<^const>\<open>Map.empty\<close> & \<^typeof>\<open>Map.empty\<close>\\
\<^const>\<open>Map.map_add\<close> & \<^typeof>\<open>Map.map_add\<close>\\
\<^const>\<open>Map.map_comp\<close> & \<^typeof>\<open>Map.map_comp\<close>\\
\<^const>\<open>Map.restrict_map\<close> & @{term_type_only Map.restrict_map "('a\<Rightarrow>'b option)\<Rightarrow>'a set\<Rightarrow>('a\<Rightarrow>'b option)"}\\
\<^const>\<open>Map.dom\<close> & @{term_type_only Map.dom "('a\<Rightarrow>'b option)\<Rightarrow>'a set"}\\
\<^const>\<open>Map.ran\<close> & @{term_type_only Map.ran "('a\<Rightarrow>'b option)\<Rightarrow>'b set"}\\
\<^const>\<open>Map.map_le\<close> & \<^typeof>\<open>Map.map_le\<close>\\
\<^const>\<open>Map.map_of\<close> & \<^typeof>\<open>Map.map_of\<close>\\
\<^const>\<open>Map.map_upds\<close> & \<^typeof>\<open>Map.map_upds\<close>\\
\end{tabular}

\subsubsection*{Syntax}

\begin{tabular}{@ {} l @ {\quad$\equiv$\quad} l @ {}}
\<^term>\<open>Map.empty\<close> & @{term[source] "\<lambda>_. None"}\\
\<^term>\<open>m(x:=Some y)\<close> & @{term[source]"m(x:=Some y)"}\\
\<open>m(x\<^sub>1\<mapsto>y\<^sub>1,\<dots>,x\<^sub>n\<mapsto>y\<^sub>n)\<close> & @{text[source]"m(x\<^sub>1\<mapsto>y\<^sub>1)\<dots>(x\<^sub>n\<mapsto>y\<^sub>n)"}\\
\<open>[x\<^sub>1\<mapsto>y\<^sub>1,\<dots>,x\<^sub>n\<mapsto>y\<^sub>n]\<close> & @{text[source]"Map.empty(x\<^sub>1\<mapsto>y\<^sub>1,\<dots>,x\<^sub>n\<mapsto>y\<^sub>n)"}\\
\<^term>\<open>map_upds m xs ys\<close> & @{term[source]"map_upds m xs ys"}\\
\end{tabular}

\section*{Infix operators in Main} % \<^theory>\<open>Main\<close>

\begin{center}
\begin{tabular}{llll}
 & Operator & precedence & associativity \\
\hline
Meta-logic & \<open>\<Longrightarrow>\<close> & 1 & right \\
& \<open>\<equiv>\<close> & 2 \\
\hline
Logic & \<open>\<and>\<close> & 35 & right \\
&\<open>\<or>\<close> & 30 & right \\
&\<open>\<longrightarrow>\<close>, \<open>\<longleftrightarrow>\<close> & 25 & right\\
&\<open>=\<close>, \<open>\<noteq>\<close> & 50 & left\\
\hline
Orderings & \<open>\<le>\<close>, \<open><\<close>, \<open>\<ge>\<close>, \<open>>\<close> & 50 \\
\hline
Sets & \<open>\<subseteq>\<close>, \<open>\<subset>\<close>, \<open>\<supseteq>\<close>, \<open>\<supset>\<close> & 50 \\
&\<open>\<in>\<close>, \<open>\<notin>\<close> & 50 \\
&\<open>\<inter>\<close> & 70 & left \\
&\<open>\<union>\<close> & 65 & left \\
\hline
Functions and Relations & \<open>\<circ>\<close> & 55 & left\\
&\<open>`\<close> & 90 & right\\
&\<open>O\<close> & 75 & right\\
&\<open>``\<close> & 90 & right\\
&\<open>^^\<close> & 80 & right\\
\hline
Numbers & \<open>+\<close>, \<open>-\<close> & 65 & left \\
&\<open>*\<close>, \<open>/\<close> & 70 & left \\
&\<open>div\<close>, \<open>mod\<close> & 70 & left\\
&\<open>^\<close> & 80 & right\\
&\<open>dvd\<close> & 50 \\
\hline
Lists & \<open>#\<close>, \<open>@\<close> & 65 & right\\
&\<open>!\<close> & 100 & left
\end{tabular}
\end{center}
\<close>
(*<*)
end
(*>*)