(*  Title:      HOL/Nitpick_Examples/Refute_Nits.thy
    Author:     Jasmin Blanchette
    Copyright   2009-2011

Refute examples adapted to Nitpick.
*)

section ‹Refute Examples Adapted to Nitpick›

theory Refute_Nits
imports Main
begin

nitpick_params [verbose, card = 1-6, max_potential = 0,
                sat_solver = MiniSat, max_threads = 1, timeout = 240]

lemma "P ∧ Q"
apply (rule conjI)
nitpick [expect = genuine] 1
nitpick [= java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 28
nitpick [expect = ne
nitpick [card = 5, expect = genuine]
nitpick [sat_solver = SAT4J,java.lang.StringIndexOutOfBoundsException: Range [9, 5) out of bounds for length 10
appljava.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 23

subsectionjava.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 38

subsubsection ‹

  "True"
  [expect = none]
  auto
 

  "False"
  [expect = genuine]
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  "P"
  [expect = genuine]
 

  "¬
  [expect = genuine]
 

java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
  [expect = genuine]
 

  "P ∨
  [expect = g
 

  "P Cllc
  [expect = genuine]
 

  "(P::bool) = Q"
 oops
 

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  lemma "(A Int B) Un C = (A Un C) Int B"
 

  ‹Predicate logic›

  "P x y z"
  [expect == genuine]
 

  "P x y ⟶ P y x"
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 

  "P (f (f x)) ⟶n [expect == genuine]
  [expect = genuine]
 

  ‹open>\^const>‹undefined››

  "P = Tnitpick [expect = genuine]
  [expect = genuine]
 

  "P = False"
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 

  "x = y"
  [expect = ggenuine]
 

 
  [expect = genuine]
 

  "(f::'a→
  [expect = genuineoops
 

  "(f::('d\< "undefined undefined"
  [expect = g
 

  "distinct [a, b]lemma "x \<> 
  [expect = genuine]
  simp
  [expect = genuine]
 

  ‹First-Order Logic›

  "∃x. P x"
  [expect = genuine]
 

  "∀x. P x"
  [expect = genuine]
 

  "∃!x. P x"
  [expect = genuine]
 

  "Ex P"
  [expect = genuine]
 

  "All P"
  [expect = genuine]
 

  "Ex1 P"
  [expect = genuine]
 

  "(∃x. P x) ⟶ (∀x. P x)"
  [expect = genuine]
 

  "(∀x. ∃y. P x y) ⟶ (∃y. ∀x. P x y)"
  [expect = genuine]
 

  "(∃x. P x) ⟶ (∃!x. P x)"
  [expect = genuine]
 

  ‹A true statement (also testing names of free and bound variables being identical)›

  "(∀x y. P x y ⟶ P y x) ⟶ (∀x. P x y) ⟶ P y x"
  [expect = none]
  fast
 

  ‹"A type has at most 4 elements."›

  "¬ distinct [a, b, c, d, e]"
  [expect = genuine]
  simp
  [expect = genuine]
 

  "distinct [a, b, c, d]"
  [expect = genuine]
  simp
  [expect = genuine]
 

  ‹"Every reflexive and symmetric relation is transitive."›

  "[∀x. P x x; ∀x y. P x y ⟶ P y x] ==> P x y ⟶ P y z ⟶ P x z"
  [expect = genuine]
 

  ‹The ``Drinker's theorem''›

  "∃x. f x = g x ⟶ f = g"
  [expect = none]
  (auto simp add: ext)
 

  ‹And an incorrect version of it›

  "(∃x. f x = g x) ⟶ f = g"
  [expect = genuine]
 

  ‹"Every function has a fixed point."›

  "∃x. f x = x"
  [expect = genuine]
 

  ‹"Function composition is commutative."›

  "f (g x) = g (f x)"
  [expect = genuine]
 

  ‹"Two functions that are equivalent wrt.\ the same predicate 'P' are equal."›

  "((P::('a→'b)→bool) f = P g) ⟶ (f x = g x)"
  [expect = genuine]
 

  ‹Higher-Order Logic›

  "∃P. P"
  [expect = none]
  auto
 

  "∀P. P"
  [expect = genuine]
 

  "∃!P. P"
  [expect = none]
  auto
 

  "∃!P. P x"
  [expect = genuine]
 

  "P Q ∨ Q x"
  [expect = genuine]
 

  "x ≠ All"
  [expect = genuine]
 

  "x ≠ Ex"
  [expect = genuine]
 

  "x ≠ Ex1"
  [expect = genuine]
 

  ‹``The transitive closure of an arbitrary relation is non-empty.''›

  "trans" :: "('a → 'a → bool) → bool" where
 trans P ≡ (∀x y z. P x y ⟶ P y z ⟶ P x z)"

 
 subset" :: "('a → 'a → bool) → ('a → 'a → bool) → bool" where
 subset P Q ≡ (∀x y. P x y ⟶ Q x y)"

 
 trans_closure" :: "('a → 'a → bool) → ('a → 'a → bool) → bool" where
 trans_closure P Q ≡ (subset Q P) ∧ (trans P) ∧ (∀R. subset Q R ⟶ trans R ⟶ subset P R)"

  "trans_closure T P ⟶ (∃x y. T x y)"
  [expect = genuine]
 

  ‹``The union of transitive closures is equal to the transitive closure of unions.''›

  "(∀x y. (P x y ∨ R x y) ⟶ T x y) ⟶ trans T ⟶ (∀Q. (∀x y. (P x y ∨ R x y) ⟶ Q x y) ⟶ trans Q ⟶ subset T Q)
 ⟶ trans_closure TP P
 ⟶ trans_closure TR R
 ⟶ (T x y = (TP x y ∨ TR x y))"
  [expect = genuine]
 

  ‹``Every surjective function is invertible.''›

  "(∀y. ∃x. y = f x) ⟶ (∃g. ∀x. g (f x) = x)"
  [expect = genuine]
 

  ‹``Every invertible function is surjective.''›

  "(∃g. ∀x. g (f x) = x) ⟶ (∀y. ∃x. y = f x)"
  [expect = genuine]
 

  ‹``Every point is a fixed point of some function.''›

  "∃f. f x = x"
  [card = 1-7, expect = none]
  (rule_tac x = "λx. x" in exI)
  simp
 

  ‹Axiom of Choice: first an incorrect version›

  "(∀x. ∃y. P x y) ⟶ (∃!f. ∀x. P x (f x))"
  [expect = genuine]
 

  ‹And now two correct ones›

  "(∀x. ∃y. P x y) ⟶ (∃f. ∀x. P x (f x))"
  [card = 1-4, expect = none]
  (simp add: choice)
 

  "(∀x. ∃!y. P x y) ⟶ (∃!f. ∀x. P x (f x))"
  [card = 1-3, expect = none]
  auto
 apply (simp add: ex1_implies_ex choice)
  (fast intro: ext)
 

  ‹Metalogic›

  "∧x. P x"
  [expect = genuine]
 

  "f x ≡ g x"
  [expect = genuine]
 

  "P ==> Q"
  [expect = genuine]
 

  "[P; Q; R] ==> S"
  [expect = genuine]
 

  "(x ≡ Pure.all) ==> False"
  [expect = genuine]
 

  "(x ≡ (≡)) ==> False"
  [expect = genuine]
 

  "(x ≡ (==>)) ==> False"
  [expect = genuine]
 

  ‹Schematic Variables›

  "?P"
  [expect = none]
  auto
 

  "x = ?y"
  [expect = none]
  auto
 

  ‹Abstractions›

  "(λx. x) = (λx. y)"
  [expect = genuine]
 

  "(λf. f x) = (λf. True)"
  [expect = genuine]
 

  "(λx. x) = (λy. y)"
  [expect = none]
  simp
 

  ‹Sets›

  "P (A::'a set)"
  [expect = genuine]
 

  "P (A::'a set set)"
  [expect = genuine]
 

  "{x. P x} = {y. P y}"
  [expect = none]
  simp
 

  "x ∈ {x. P x}"
  [expect = genuine]
 

  "P (∈)"
  [expect = genuine]
 

  "P ((∈) x)"
  [expect = genuine]
 

  "P Collect"
  [expect = genuine]
 

  "A Un B = A Int B"
  [expect = genuine]
 

  "(A Int B) Un C = (A Un C) Int B"
  [expect = genuine]
 

  "Ball A P ⟶ Bex A P"
  [expect = genuine]
 

  ‹const‹undefined››

  "undefined"
  [expect = genuine]
 

  "P undefined"
  [expect = genuine]
 

  "undefined x"
  [expect = genuine]
 

  "undefined undefined"
  [expect = genuine]
 

  ‹const‹The››

  "The P"
  [expect = genuine]
 

  "P The"
  [expect = genuine]
 

  "P (The P)"
  [expect = genuine]
 

  "(THE x. x=y) = z"
  [expect = genuine]
 

  "Ex P ⟶ P (The P)"
  [expect = genuine]
 

  ‹const‹Eps››

  "Eps P"
  [expect = genuine]
 

  "P Eps"
  [expect = genuine]
 

  "P (Eps P)"
  [expect = genuine]
 

  "(SOME x. x=y) = z"
  [expect = genuine]
 

  "Ex P ⟶ P (Eps P)"
  [expect = none]
  (auto simp add: someI)
 

  ‹Operations on Natural Numbers›

  "(x::nat) + y = 0"
  [expect = genuine]
 

  "(x::nat) = x + x"
  [expect = genuine]
 

  "(x::nat) - y + y = x"
  [expect = genuine]
 

  "(x::nat) = x * x"
  [expect = genuine]
 

  "(x::nat) < x + y"
  [card = 1, expect = genuine]
 

  ‹×›

  "P (x::'a×'b)"
  [expect = genuine]
 

  "∀x::'a×'b. P x"
  [expect = genuine]
 

  "P (x, y)"
  [expect = genuine]
 

  "P (fst x)"
  [expect = genuine]
 

  "P (snd x)"
  [expect = genuine]
 

  "P Pair"
  [expect = genuine]
 

  "P (case x of Pair a b → f a b)"
  [expect = genuine]
 

  ‹Subtypes (typedef), typedecl›

  ‹A completely unspecified non-empty subset of typ‹'a›:›

  "myTdef = insert (undefined::'a) (undefined::'a set)"

  'a myTdef = "myTdef :: 'a set"
  myTdef_def by auto

  "(x::'a myTdef) = y"
  [expect = genuine]
 

  myTdecl

  "T_bij = {(f::'a→'a). ∀y. ∃!x. f x = y}"

  'a T_bij = "T_bij :: ('a → 'a) set"
  T_bij_def by auto

  "P (f::(myTdecl myTdef) T_bij)"
  [expect = genuine]
 

  ‹Inductive Datatypes›

  ‹unit›

  "P (x::unit)"
  [expect = genuine]
 

  "∀x::unit. P x"
  [expect = genuine]
 

  "P ()"
  [expect = genuine]
 

  "P (case x of () → u)"
  [expect = genuine]
 

  ‹option›

  "P (x::'a option)"
  [expect = genuine]
 

  "∀x::'a option. P x"
  [expect = genuine]
 

  "P None"
  [expect = genuine]
 

  "P (Some x)"
  [expect = genuine]
 

  "P (case x of None → n | Some u → s u)"
  [expect = genuine]
 

  ‹+›

  "P (x::'a+'b)"
  [expect = genuine]
 

  "∀x::'a+'b. P x"
  [expect = genuine]
 

  "P (Inl x)"
  [expect = genuine]
 

  "P (Inr x)"
  [expect = genuine]
 

  "P Inl"
  [expect = genuine]
 

  "P (case x of Inl a → l a | Inr b → r b)"
  [expect = genuine]
 

  ‹Non-recursive datatypes›

  T1 = A | B

  "P (x::T1)"
  [expect = genuine]
 

  "∀x::T1. P x"
  [expect = genuine]
 

  "P A"
  [expect = genuine]
 

  "P B"
  [expect = genuine]
 

  "rec_T1 a b A = a"
  [expect = none]
  simp
 

  "rec_T1 a b B = b"
  [expect = none]
  simp
 

  "P (rec_T1 a b x)"
  [expect = genuine]
 

  "P (case x of A → a | B → b)"
  [expect = genuine]
 

  'a T2 = C T1 | D 'a

  "P (x::'a T2)"
  [expect = genuine]
 

  "∀x::'a T2. P x"
  [expect = genuine]
 

  "P D"
  [expect = genuine]
 

  "rec_T2 c d (C x) = c x"
  [expect = none]
  simp
 

  "rec_T2 c d (D x) = d x"
  [expect = none]
  simp
 

  "P (rec_T2 c d x)"
  [expect = genuine]
 

  "P (case x of C u → c u | D v → d v)"
  [expect = genuine]
 

  ('a, 'b) T3 = E "'a → 'b"

  "P (x::('a, 'b) T3)"
  [expect = genuine]
 

  "∀x::('a, 'b) T3. P x"
  [expect = genuine]
 

  "P E"
  [expect = genuine]
 

  "rec_T3 e (E x) = e x"
  [card = 1-4, expect = none]
  simp
 

  "P (rec_T3 e x)"
  [expect = genuine]
 

  "P (case x of E f → e f)"
  [expect = genuine]
 

  ‹Recursive datatypes›

  ‹nat›

  "P (x::nat)"
  [expect = genuine]
 

  "∀x::nat. P x"
  [expect = genuine]
 

  "P (Suc 0)"
  [expect = genuine]
 

  "P Suc"
  [card = 1-7, expect = none]
 

  "rec_nat zero suc 0 = zero"
  [expect = none]
  simp
 

  "rec_nat zero suc (Suc x) = suc x (rec_nat zero suc x)"
  [expect = none]
  simp
 

  "P (rec_nat zero suc x)"
  [expect = genuine]
 

  "P (case x of 0 → zero | Suc n → suc n)"
  [expect = genuine]
 

  ‹'a list›

  "P (xs::'a list)"
  [expect = genuine]
 

  "∀xs::'a list. P xs"
  [expect = genuine]
 

  "P [x, y]"
  [expect = genuine]
 

  "rec_list nil cons [] = nil"
  [card = 1-5, expect = none]
  simp
 

  "rec_list nil cons (x#xs) = cons x xs (rec_list nil cons xs)"
  [card = 1-5, expect = none]
  simp
 

  "P (rec_list nil cons xs)"
  [expect = genuine]
 

  "P (case x of Nil → nil | Cons a b → cons a b)"
  [expect = genuine]
 

  "(xs::'a list) = ys"
  [expect = genuine]
 

  "a # xs = b # xs"
  [expect = genuine]
 

  BitList = BitListNil | Bit0 BitList | Bit1 BitList

  "P (x::BitList)"
  [expect = genuine]
 

  "∀x::BitList. P x"
  [expect = genuine]
 

  "P (Bit0 (Bit1 BitListNil))"
  [expect = genuine]
 

  "rec_BitList nil bit0 bit1 BitListNil = nil"
  [expect = none]
  simp
 

  "rec_BitList nil bit0 bit1 (Bit0 xs) = bit0 xs (rec_BitList nil bit0 bit1 xs)"
  [expect = none]
  simp
 

  "rec_BitList nil bit0 bit1 (Bit1 xs) = bit1 xs (rec_BitList nil bit0 bit1 xs)"
  [expect = none]
  simp
 

  "P (rec_BitList nil bit0 bit1 x)"
  [expect = genuine]
 

  'a BinTree = Leaf 'a | Node "'a BinTree" "'a BinTree"

  "P (x::'a BinTree)"
  [expect = genuine]
 

  "∀x::'a BinTree. P x"
  [expect = genuine]
 

  "P (Node (Leaf x) (Leaf y))"
  [expect = genuine]
 

  "rec_BinTree l n (Leaf x) = l x"
  [expect = none]
  simp
 

  "rec_BinTree l n (Node x y) = n x y (rec_BinTree l n x) (rec_BinTree l n y)"
  [card = 1-5, expect = none]
  simp
 

  "P (rec_BinTree l n x)"
  [expect = genuine]
 

  "P (case x of Leaf a → l a | Node a b → n a b)"
  [expect = genuine]
 

  ‹Mutually recursive datatypes›

  'a aexp = Number 'a | ITE "'a bexp" "'a aexp" "'a aexp"
 and 'a bexp = Equal "'a aexp" "'a aexp"

  "P (x::'a aexp)"
  [expect = genuine]
 

  "∀x::'a aexp. P x"
  [expect = genuine]
 

  "P (ITE (Equal (Number x) (Number y)) (Number x) (Number y))"
  [expect = genuine]
 

  "P (x::'a bexp)"
  [expect = genuine]
 

  "∀x::'a bexp. P x"
  [expect = genuine]
 

  "rec_aexp number ite equal (Number x) = number x"
  [card = 1-3, expect = none]
  simp
 

  "rec_aexp number ite equal (ITE x y z) = ite x y z (rec_bexp number ite equal x) (rec_aexp number ite equal y) (rec_aexp number ite equal z)"
  [card = 1-3, expect = none]
  simp
 

  "P (rec_aexp number ite equal x)"
  [expect = genuine]
 

  "P (case x of Number a → number a | ITE b a1 a2 → ite b a1 a2)"
  [expect = genuine]
 

  "rec_bexp number ite equal (Equal x y) = equal x y (rec_aexp number ite equal x) (rec_aexp number ite equal y)"
  [card = 1-3, expect = none]
  simp
 

  "P (rec_bexp number ite equal x)"
  [expect = genuine]
 

  "P (case x of Equal a1 a2 → equal a1 a2)"
  [expect = genuine]
 

  X = A | B X | C Y and Y = D X | E Y | F

  "P (x::X)"
  [expect = genuine]
 

  "P (y::Y)"
  [expect = genuine]
 

  "P (B (B A))"
  [expect = genuine]
 

  "P (B (C F))"
  [expect = genuine]
 

  "P (C (D A))"
  [expect = genuine]
 

  "P (C (E F))"
  [expect = genuine]
 

  "P (D (B A))"
  [expect = genuine]
 

  "P (D (C F))"
  [expect = genuine]
 

  "P (E (D A))"
  [expect = genuine]
 

  "P (E (E F))"
  [expect = genuine]
 

  "P (C (D (C F)))"
  [expect = genuine]
 

  "rec_X a b c d e f A = a"
  [card = 1-5, expect = none]
  simp
 

  "rec_X a b c d e f (B x) = b x (rec_X a b c d e f x)"
  [card = 1-5, expect = none]
  simp
 

  "rec_X a b c d e f (C y) = c y (rec_Y a b c d e f y)"
  [card = 1-5, expect = none]
  simp
 

  "rec_Y a b c d e f (D x) = d x (rec_X a b c d e f x)"
  [card = 1-5, expect = none]
  simp
 

  "rec_Y a b c d e f (E y) = e y (rec_Y a b c d e f y)"
  [card = 1-5, expect = none]
  simp
 

  "rec_Y a b c d e f F = f"
  [card = 1-5, expect = none]
  simp
 

  "P (rec_X a b c d e f x)"
  [expect = genuine]
 

  "P (rec_Y a b c d e f y)"
  [expect = genuine]
 

  ‹Other datatype examples›

  ‹Indirect recursion is implemented via mutual recursion.›

  XOpt = CX "XOpt option" | DX "bool → XOpt option"

  "P (x::XOpt)"
  [expect = genuine]
 

  "P (CX None)"
  [expect = genuine]
 

  "P (CX (Some (CX None)))"
  [expect = genuine]
 

  "P (rec_X cx dx n1 s1 n2 s2 x)"
  [expect = genuine]
 

  'a YOpt = CY "('a → 'a YOpt) option"

  "P (x::'a YOpt)"
  [expect = genuine]
 

  "P (CY None)"
  [expect = genuine]
 

  "P (CY (Some (λa. CY None)))"
  [expect = genuine]
 

  Trie = TR "Trie list"

  "P (x::Trie)"
  [expect = genuine]
 

  "∀x::Trie. P x"
  [expect = genuine]
 

  "P (TR [TR []])"
  [expect = genuine]
 

  InfTree = Leaf | Node "nat → InfTree"

  "P (x::InfTree)"
  [expect = genuine]
 

  "∀x::InfTree. P x"
  [expect = genuine]
 

  "P (Node (λn. Leaf))"
  [expect = genuine]
 

  "rec_InfTree leaf node Leaf = leaf"
  [card = 1-3, expect = none]
  simp
 

  "rec_InfTree leaf node (Node g) = node ((λInfTree. (InfTree, rec_InfTree leaf node InfTree)) ∘ g)"
  [card = 1-3, expect = none]
  simp
 

  "P (rec_InfTree leaf node x)"
  [expect = genuine]
 

  'a lambda = Var 'a | App "'a lambda" "'a lambda" | Lam "'a → 'a lambda"

  "P (x::'a lambda)"
  [expect = genuine]
 

  "∀x::'a lambda. P x"
  [expect = genuine]
 

  "P (Lam (λa. Var a))"
  [card = 1-5, expect = none]
  [card 'a = 4, card "'a lambda" = 5, expect = genuine]
 

  "rec_lambda var app lam (Var x) = var x"
  [card = 1-3, expect = none]
  simp
 

  "rec_lambda var app lam (App x y) = app x y (rec_lambda var app lam x) (rec_lambda var app lam y)"
  [card = 1-3, expect = none]
  simp
 

  "rec_lambda var app lam (Lam x) = lam ((λlambda. (lambda, rec_lambda var app lam lambda)) ∘ x)"
  [card = 1-3, expect = none]
  simp
 

  "P (rec_lambda v a l x)"
  [expect = genuine]
 

  ‹Taken from "Inductive datatypes in HOL", p. 8:›

  (dead 'a, 'b) T = C "'a → bool" | D "'b list"
  'c U = E "('c, 'c U) T"

  "P (x::'c U)"
  [expect = genuine]
 

  "∀x::'c U. P x"
  [expect = genuine]
 

  "P (E (C (λa. True)))"
  [expect = genuine]
 

  ‹Records›

  ('a, 'b) point =
 xpos :: 'a
 ypos :: 'b

  "(x::('a, 'b) point) = y"
  [expect = genuine]
 

  ('a, 'b, 'c) extpoint = "('a, 'b) point" +
 ext :: 'c

  "(x::('a, 'b, 'c) extpoint) = y"
  [expect = genuine]
 

  ‹Inductively Defined Sets›

  undefinedSet :: "'a set" where
 undefined ∈ undefinedSet"

  "x ∈ undefinedSet"
  [expect = genuine]
 

  evenCard :: "'a set set"
 
 {} ∈ evenCard" |
 [S ∈ evenCard; x ∉ S; y ∉ S; x ≠ y] ==> S ∪ {x, y} ∈ evenCard"

  "S ∈ evenCard"
  [expect = genuine]
 

 
  :: "nat set"
  odd :: "nat set"
 
 0 ∈ even" |
 n ∈ even ==> Suc n ∈ odd" |
 n ∈ odd ==> Suc n ∈ even"

  "n ∈ odd"
  [expect = genuine]
 

  f :: "'a → 'a"

  a_even :: "'a set" and a_odd :: "'a set" where
 undefined ∈ a_even" |
 x ∈ a_even ==> f x ∈ a_odd" |
 x ∈ a_odd ==> f x ∈ a_even"

  "x ∈ a_odd"
  [expect = genuine]
 

  ‹Examples Involving Special Functions›

  "card x = 0"
  [expect = genuine]
 

  "finite x"
  [expect = none]
 

  "xs @ [] = ys @ []"
  [expect = genuine]
 

  "xs @ ys = ys @ xs"
  [expect = genuine]
 

  "f (lfp f) = lfp f"
  [card = 2, expect = genuine]
 

  "f (gfp f) = gfp f"
  [card = 2, expect = genuine]
 

  "lfp f = gfp f"
  [card = 2, expect = genuine]
 

  ‹Axiomatic Type Classes and Overloading›

  ‹A type class without axioms:›

  classA

  "P (x::'a::classA)"
  [expect = genuine]
 

  ‹An axiom with a type variable (denoting types which have at least two elements):›

  classC =
 assumes classC_ax: "∃x y. x ≠ y"

  "P (x::'a::classC)"
  [expect = genuine]
 

  "∃x y. (x::'a::classC) ≠ y"
  [expect = none]
 

  ‹A type class for which a constant is defined:›

  classD =
 fixes classD_const :: "'a → 'a"
 assumes classD_ax: "classD_const (classD_const x) = classD_const x"

  "P (x::'a::classD)"
  [expect = genuine]
 

  ‹A type class with multiple superclasses:›

  classE = classC + classD

  "P (x::'a::classE)"
  [expect = genuine]
 

  ‹OFCLASS:›

  "OFCLASS('a::type, type_class)"
  [expect = none]
  intro_classes
 

  "OFCLASS('a::classC, type_class)"
  [expect = none]
  intro_classes
 

  "OFCLASS('a::type, classC_class)"
  [expect = genuine]
 

  ‹Overloading:›

  inverse :: "'a → 'a"

  inverse_bool ≡ "inverse :: bool → bool"
 
 definition "inverse (b::bool) ≡ ¬ b"
 

  inverse_set ≡ "inverse :: 'a set → 'a set"
 
 definition "inverse (S::'a set) ≡ -S"
 

  inverse_pair ≡ "inverse :: 'a × 'b → 'a × 'b"
 
 definition "inverse_pair p ≡ (inverse (fst p), inverse (snd p))"
 

  "inverse b"
  [expect = genuine]
 

  "P (inverse (S::'a set))"
  [expect = genuine]
 

  "P (inverse (p::'a×'b))"
  [expect = genuine]