[isabelle-dev] [158c513a39f5] JVM crash
Manuel Eberl
eberlm at in.tum.de
Tue Nov 7 09:51:54 CET 2017
It seems like this thread is not dead yet.
I had my CPU replaced by a new version that supposedly does not have the
SMD problem on Linux. The problem with Isabelle did not go away.
I still get reproducible crashes of "isabelle build -c Pure", but only
with SMT switched on. However, it is worth noting that the crashes
always seem to happen at the end of the build process. (A successful
build takes about 9 seconds of elapsed and CPU time on my machine and
unsuccessful ones always crash at at least that time) However, it is
worth noting that some of the failed builds look like this:
0:00:30 elapsed time, 0:00:08 cpu time, factor 0.29
Also, the last line that is printed is always
### theory "ML_Bootstrap"
so perhaps that also points to some specific problem. However, I don't
think it's anything specific to Pure, since the crash is also
reproducible with other sessions if I remember correctly (I just use
Pure because it can be built quickly).
To summarise:
- crash happens randomly in about 6% of builds of the "Pure" session
- crash seems specific to my Ryzen or at least my system
- disabling SMT makes problem go away
- crash reproducible on my Arch installation and a fresh install of
Arch, but not on Ubuntu
- RAM passes memtest without errors
- I did not experience instability with any other software
- My conjecture would be that it is somehow related to PolyML and
multithreading
I attached both the console output and the build log.
Manuel
On 04/09/17 15:12, Manuel Eberl wrote:
> Alas, it would appear I have spoken too soon!
>
> I experienced a strange build failure with RC1 yesterday and, fearing
> the worst, did my experiment from a few weeks ago again, with the
> following result:
>
> – building "Pure" fails in around 6 % of the cases
> – this does not change even after a cold reboot
> – switching SMT off seems to make the problem go away entirely
> – switching SMT on makes it reappear
>
> Sounds very much like this might well be the Ryzen bug. AMD has started
> replacing affected CPUs, so I shall enquire about that and see what happens.
>
> Cheers,
>
> Manuel
-------------- next part --------------
signature BASIC_EXN =
sig
exception ERROR of string
val cat_error: string -> string -> 'a
val error: string -> 'a
end
signature EXN =
sig
exception ERROR of string
exception EXCEPTIONS of exn list
exception Interrupt
val capture: ('a -> 'b) -> 'a -> 'b result
val capture_exit: int -> ('a -> 'b) -> 'a -> 'b
val cat_error: string -> string -> 'a
val error: string -> 'a
val get_exn: 'a result -> exn option
val get_res: 'a result -> 'a option
val interrupt: unit -> 'a
val interrupt_exn: 'a result
val interruptible_capture: ('a -> 'b) -> 'a -> 'b result
val is_interrupt: exn -> bool
val is_interrupt_exn: 'a result -> bool
val map_exn: (exn -> exn) -> 'a result -> 'a result
val map_res: ('a -> 'b) -> 'a result -> 'b result
val maps_res: ('a -> 'b result) -> 'a result -> 'b result
val polyml_location: exn -> PolyML.location option
val release: 'a result -> 'a
val reraise: exn -> 'a
datatype 'a result = Exn of exn | Res of 'a
val return_code: exn -> int -> int
val trace: (exn -> string) -> (string -> unit) -> (unit -> 'a) -> 'a
end
structure Exn: EXN
val it = (): unit
signature OUTPUT_PRIMITIVES =
sig
val error_message_fn: serial * output list -> unit
val ignore_outputs: output list -> unit
val information_fn: output list -> unit
val legacy_fn: output list -> unit
val markup_fn: string * properties -> output * output
eqtype output
type properties = (string * string) list
val protocol_message_fn: properties -> output list -> unit
val report_fn: output list -> unit
val result_fn: properties -> output list -> unit
eqtype serial
val state_fn: output list -> unit
val status_fn: output list -> unit
val system_message_fn: output list -> unit
val tracing_fn: output list -> unit
val warning_fn: output list -> unit
val writeln_fn: output list -> unit
end
structure Output_Primitives: OUTPUT_PRIMITIVES
val it = (): unit
signature THREAD_ATTRIBUTES =
sig
type attributes
val convert_attributes: attributes -> Thread.Thread.threadAttribute list
val expose_interrupt: unit -> unit
val get_attributes: unit -> attributes
val no_interrupts: attributes
val private_interrupts: attributes
val public_interrupts: attributes
val safe_interrupts: attributes -> attributes
val set_attributes: attributes -> unit
val sync_interrupts: attributes -> attributes
val test_interrupts: attributes
val uninterruptible: ((('a -> 'b) -> 'a -> 'b) -> 'c -> 'd) -> 'c -> 'd
val with_attributes: attributes -> (attributes -> 'a) -> 'a
end
structure Thread_Attributes: THREAD_ATTRIBUTES
val it = (): unit
signature THREAD_DATA =
sig
val get: 'a var -> 'a option
val is_virtual: bool
val put: 'a var -> 'a option -> unit
val setmp: 'a var -> 'a option -> ('b -> 'c) -> 'b -> 'c
val var: unit -> 'a var
type 'a var
end
structure Thread_Data: THREAD_DATA
val it = (): unit
signature THREAD_POSITION =
sig
type T =
{end_offset: int,
line: int, offset: int, props: (string * string) list}
val get: unit -> T
val none: T
val setmp: T -> ('a -> 'b) -> 'a -> 'b
end
structure Thread_Position: THREAD_POSITION
val it = (): unit
signature ML_RECURSIVE =
sig
type env =
{add_breakpoints: (int * (bool ref * Thread_Position.T)) list -> unit,
debug: bool, name_space: PolyML.NameSpace.nameSpace}
val get: unit -> env option
val recursive: env -> (unit -> 'a) -> 'a
end
structure ML_Recursive: ML_RECURSIVE
val it = (): unit
val it = (): unit
signature ML_NAME_SPACE =
sig
type T
val bootstrap_signatures: string list
val bootstrap_structures: string list
val bootstrap_values: string list
val forget_structure: string -> unit
val forget_type: string -> unit
val forget_val: string -> unit
val global: T
val global_values: (string * string) list -> T
val hidden_structures: string list
val sml_fixity: (string * PolyML.NameSpace.Infixes.fixity) list
val sml_functor: (string * PolyML.NameSpace.Functors.functorVal) list
val sml_signature:
(string * PolyML.NameSpace.Signatures.signatureVal) list
val sml_structure:
(string * PolyML.NameSpace.Structures.structureVal) list
val sml_type: (string * PolyML.NameSpace.TypeConstrs.typeConstr) list
val sml_val: (string * PolyML.NameSpace.Values.value) list
end
structure ML_Name_Space: ML_NAME_SPACE
val it = (): unit
val it = (): unit
structure PolyML_Pretty:
sig
datatype context =
ContextLocation of PolyML.location
| ContextProperty of string * string
datatype pretty =
PrettyBlock of int * bool * context list * pretty list
| PrettyBreak of int * int
| PrettyLineBreak
| PrettyString of string
| PrettyStringWithWidth of string * int
end
val seconds = fn: real -> Time.time
val ord = fn: string -> int
val chr = fn: int -> string
val raw_explode = fn: string -> string list
val implode = fn: string list -> string
val pointer_eq = fn: 'a * 'a -> bool
val error_depth = fn: int -> unit
structure ConditionVar:
sig
val broadcast: conditionVar -> unit
val conditionVar: unit -> conditionVar
type conditionVar
val signal: conditionVar -> unit
val wait: conditionVar * Mutex.mutex -> unit
val waitUntil: conditionVar * Mutex.mutex * Time.time -> bool
end
structure Mutex:
sig
val lock: mutex -> unit
val mutex: unit -> mutex
type mutex
val trylock: mutex -> bool
val unlock: mutex -> unit
end
structure Thread:
sig
exception Interrupt
val broadcastInterrupt: unit -> unit
val equal: thread * thread -> bool
val exit: unit -> unit
val fork: (unit -> unit) * threadAttribute list -> thread
val getAttributes: unit -> threadAttribute list
val getLocal: 'a Universal.tag -> 'a option
val interrupt: thread -> unit
datatype interruptState =
InterruptAsynch
| InterruptAsynchOnce
| InterruptDefer
| InterruptSynch
val isActive: thread -> bool
val kill: thread -> unit
val numPhysicalProcessors: unit -> int option
val numProcessors: unit -> int
val self: unit -> thread
val setAttributes: threadAttribute list -> unit
val setLocal: 'a Universal.tag * 'a -> unit
val testInterrupt: unit -> unit
type thread
datatype threadAttribute =
EnableBroadcastInterrupt of bool
| InterruptState of interruptState
| MaximumMLStack of int option
end
exception Thread of string
datatype illegal = Interrupt
structure Basic_Exn: BASIC_EXN
exception ERROR of string
val cat_error = fn: string -> string -> 'a
val error = fn: string -> 'a
val it = (): unit
signature ML_SYSTEM =
sig
val name: string
val platform: string
val platform_is_windows: bool
val platform_path: string -> string
val standard_path: string -> string
end
structure ML_System: ML_SYSTEM
val it = (): unit
structure Distribution:
sig val is_identified: bool val is_official: bool val version: string end
val it = (): unit
infix 1 ##>
infix 1 ##>>
infix 1 #->
infix 1 #>
infix 1 #>>
signature BASICS =
sig
val ##>: ('a -> 'b * 'c) * ('c -> 'd) -> 'a -> 'b * 'd
val ##>>: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val #->: ('a -> 'b * 'c) * ('b -> 'c -> 'd) -> 'a -> 'd
val #>: ('a -> 'b) * ('b -> 'c) -> 'a -> 'c
val #>>: ('a -> 'b * 'c) * ('b -> 'd) -> 'a -> 'd * 'c
val `: ('a -> 'b) -> 'a -> 'b * 'a
val append: 'a list -> 'a list -> 'a list
val can: ('a -> 'b) -> 'a -> bool
val cons: 'a -> 'a list -> 'a list
val eq_option: ('a * 'b -> bool) -> 'a option * 'b option -> bool
val fold: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val fold_map: ('a -> 'b -> 'c * 'b) -> 'a list -> 'b -> 'c list * 'b
val fold_rev: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val is_none: 'a option -> bool
val is_some: 'a option -> bool
val merge_options: 'a option * 'a option -> 'a option
val perhaps: ('a -> 'a option) -> 'a -> 'a
val tap: ('a -> 'b) -> 'a -> 'a
val the: 'a option -> 'a
val the_default: 'a -> 'a option -> 'a
val the_list: 'a option -> 'a list
val these: 'a list option -> 'a list
val try: ('a -> 'b) -> 'a -> 'b option
val |->: ('a * 'b) * ('a -> 'b -> 'c) -> 'c
val |>: 'a * ('a -> 'b) -> 'b
val |>>: ('a * 'b) * ('a -> 'c) -> 'c * 'b
val ||>: ('a * 'b) * ('b -> 'c) -> 'a * 'c
val ||>>: ('a * 'b) * ('b -> 'c * 'd) -> ('a * 'c) * 'd
end
infix 1 |->
infix 1 |>
infix 1 |>>
infix 1 ||>
infix 1 ||>>
structure Basics: BASICS
val ##> = fn: ('a -> 'b * 'c) * ('c -> 'd) -> 'a -> 'b * 'd
val ##>> = fn: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val #-> = fn: ('a -> 'b * 'c) * ('b -> 'c -> 'd) -> 'a -> 'd
val #> = fn: ('a -> 'b) * ('b -> 'c) -> 'a -> 'c
val #>> = fn: ('a -> 'b * 'c) * ('b -> 'd) -> 'a -> 'd * 'c
val ` = fn: ('a -> 'b) -> 'a -> 'b * 'a
val append = fn: 'a list -> 'a list -> 'a list
val can = fn: ('a -> 'b) -> 'a -> bool
val cons = fn: 'a -> 'a list -> 'a list
val eq_option = fn: ('a * 'b -> bool) -> 'a option * 'b option -> bool
val fold = fn: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val fold_map = fn: ('a -> 'b -> 'c * 'b) -> 'a list -> 'b -> 'c list * 'b
val fold_rev = fn: ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val is_none = fn: 'a option -> bool
val is_some = fn: 'a option -> bool
val merge_options = fn: 'a option * 'a option -> 'a option
val perhaps = fn: ('a -> 'a option) -> 'a -> 'a
val tap = fn: ('a -> 'b) -> 'a -> 'a
val the = fn: 'a option -> 'a
val the_default = fn: 'a -> 'a option -> 'a
val the_list = fn: 'a option -> 'a list
val these = fn: 'a list option -> 'a list
val try = fn: ('a -> 'b) -> 'a -> 'b option
val |-> = fn: ('a * 'b) * ('a -> 'b -> 'c) -> 'c
val |> = fn: 'a * ('a -> 'b) -> 'b
val |>> = fn: ('a * 'b) * ('a -> 'c) -> 'c * 'b
val ||> = fn: ('a * 'b) * ('b -> 'c) -> 'a * 'c
val ||>> = fn: ('a * 'b) * ('b -> 'c * 'd) -> ('a * 'c) * 'd
val it = (): unit
structure Symbol: sig val explode: string -> string list end
val it = (): unit
signature MULTITHREADING =
sig
val enabled: unit -> bool
val max_threads: unit -> int
val max_threads_update: int -> unit
val sync_wait:
Time.time option ->
ConditionVar.conditionVar -> Mutex.mutex -> bool Exn.result
val synchronized: string -> Mutex.mutex -> (unit -> 'a) -> 'a
val trace: int ref
val tracing: int -> (unit -> string) -> unit
val tracing_time: bool -> Time.time -> (unit -> string) -> unit
end
structure Multithreading: MULTITHREADING
val it = (): unit
signature UNSYNCHRONIZED =
sig
val !: 'a ref -> 'a
val :=: 'a ref * 'a -> unit
val change: 'a ref -> ('a -> 'a) -> unit
val change_result: 'a ref -> ('a -> 'b * 'a) -> 'b
val dec: int ref -> int
val inc: int ref -> int
datatype 'a ref = ref of 'a
val setmp: 'a ref -> 'a -> ('b -> 'c) -> 'b -> 'c
end
structure Unsynchronized: UNSYNCHRONIZED
val it = (): unit
val it = (): unit
val it = (): unit
signature SYNCHRONIZED =
sig
val change: 'a var -> ('a -> 'a) -> unit
val change_result: 'a var -> ('a -> 'b * 'a) -> 'b
val guarded_access: 'a var -> ('a -> ('b * 'a) option) -> 'b
val timed_access:
'a var ->
('a -> Time.time option) -> ('a -> ('b * 'a) option) -> 'b option
val value: 'a var -> 'a
val var: string -> 'a -> 'a var
type 'a var
end
structure Synchronized: SYNCHRONIZED
val it = (): unit
signature COUNTER = sig val make: unit -> unit -> int end
structure Counter: COUNTER
val it = (): unit
signature ML_HEAP =
sig
val obj_size: 'a -> int
val save_child: string -> unit
val share_common_data: unit -> unit
end
structure ML_Heap: ML_HEAP
val it = (): unit
signature ML_PROFILING =
sig
val profile_allocations:
((int * string) list -> unit) -> ('a -> 'b) -> 'a -> 'b
val profile_time: ((int * string) list -> unit) -> ('a -> 'b) -> 'a -> 'b
val profile_time_thread:
((int * string) list -> unit) -> ('a -> 'b) -> 'a -> 'b
end
structure ML_Profiling: ML_PROFILING
val it = (): unit
signature ML_PRINT_DEPTH =
sig val get_print_depth: unit -> int val set_print_depth: int -> unit end
structure ML_Print_Depth: ML_PRINT_DEPTH
val it = (): unit
signature ML_PRETTY =
sig
val block: pretty list -> pretty
val brk: int -> pretty
val default_margin: int
val enum:
string ->
string -> string -> ('a * int -> pretty) -> 'a list * int -> pretty
val format: int -> pretty -> string
val format_polyml: int -> PolyML.pretty -> string
val from_polyml: PolyML.pretty -> pretty
val make_string_fn: string
val pair:
('a * int -> pretty) ->
('b * int -> pretty) -> ('a * 'b) * int -> pretty
datatype pretty =
Block of (string * string) * bool * int * pretty list
| Break of bool * int * int
| String of string * int
val str: string -> pretty
val string_of_polyml: PolyML.pretty -> string
val to_polyml: pretty -> PolyML.pretty
end
ML/ml_pretty.ML:75: warning: Matches are not exhaustive.
Found near
fun
convert _ (... ...) = Break (false, ...) |
convert _ ... = Break (...) |
convert ... = let ... in ... end |
convert ... = ...
structure ML_Pretty: ML_PRETTY
val it = (): unit
signature ML_COMPILER0 =
sig
val ML:
context ->
{debug: bool, file: string, line: int, verbose: bool} ->
string -> unit
val ML_file: context -> {debug: bool, verbose: bool} -> string -> unit
val ML_file_operations:
(bool option -> string -> unit) ->
{ML_file: string -> unit,
ML_file_debug: string -> unit, ML_file_no_debug: string -> unit}
type context =
{error: string -> unit,
here: int -> string -> string,
name_space: ML_Name_Space.T,
print: string -> unit, print_depth: int option}
val debug_option: bool option -> bool
val make_context: ML_Name_Space.T -> context
type polyml_location = PolyML.location
end
structure ML_Compiler0: ML_COMPILER0
val ML_file = fn: string -> unit
val ML_file_debug = fn: string -> unit
val ML_file_no_debug = fn: string -> unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
infix 2 ?
infix 3 o
infix 3 oo
infix 3 ooo
infix 3 oooo
infix 4 ~~
infix 4 upto
infix 4 downto
infix 0 orf
infix 0 andf
signature BASIC_LIBRARY =
sig
val ?: bool * ('a -> 'a) -> 'a -> 'a
structure Any: sig type T end
val I: 'a -> 'a
val K: 'a -> 'b -> 'a
val align_right: string -> int -> string -> string
val andf: ('a -> bool) * ('a -> bool) -> 'a -> bool
val apfst: ('a -> 'b) -> 'a * 'c -> 'b * 'c
val apply2: ('a -> 'b) -> 'a * 'a -> 'b * 'b
val apsnd: ('a -> 'b) -> 'c * 'a -> 'c * 'b
val bool_ord: bool * bool -> order
val burrow: ('a list -> 'b list) -> 'a list list -> 'b list list
val burrow_fst: ('a list -> 'b list) -> ('a * 'c) list -> ('b * 'c) list
val burrow_options:
('a list -> 'b list) -> 'a option list -> 'b option list
val cartouche: string -> string
val cat_lines: string list -> string
val chop: int -> 'a list -> 'a list * 'a list
val chop_groups: int -> 'a list -> 'a list list
val chop_prefix:
('a * 'b -> bool) ->
'a list * 'b list -> 'a list * ('a list * 'b list)
val combine: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val commas: string list -> string
val commas_quote: string list -> string
val curry: ('a * 'b -> 'c) -> 'a -> 'b -> 'c
val decode_lines: string -> string
val dict_ord: ('a * 'b -> order) -> 'a list * 'b list -> order
val distinct: ('a * 'a -> bool) -> 'a list -> 'a list
val divide_and_conquer: ('a -> 'a list * ('b list -> 'b)) -> 'a -> 'b
val divide_and_conquer':
('a -> 'b -> ('a list * ('c list * 'b -> 'c * 'b)) * 'b) ->
'a -> 'b -> 'c * 'b
val downto: int * int -> int list
val drop: int -> 'a list -> 'a list
val duplicates: ('a * 'a -> bool) -> 'a list -> 'a list
val enclose: string -> string -> string -> string
val encode_lines: string -> string
val eq_fst: ('a * 'b -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val eq_list: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val eq_pair:
('a * 'b -> bool) ->
('c * 'd -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val eq_set: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val eq_snd: ('a * 'b -> bool) -> ('c * 'a) * ('d * 'b) -> bool
val equal: ''a -> ''a -> bool
val exists: ('a -> bool) -> 'a list -> bool
val exists_string: (string -> bool) -> string -> bool
val fast_string_ord: string * string -> order
val filter: ('a -> bool) -> 'a list -> 'a list
val filter_out: ('a -> bool) -> 'a list -> 'a list
val find_first: ('a -> bool) -> 'a list -> 'a option
val find_index: ('a -> bool) -> 'a list -> int
val first_field: string -> string -> (string * string) option
val flat: 'a list list -> 'a list
val fold2: ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val fold_burrow:
('a list -> 'b -> 'c list * 'd) ->
'a list list -> 'b -> 'c list list * 'd
val fold_index: (int * 'a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val fold_product:
('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val fold_range: (int -> 'a -> 'a) -> int -> 'a -> 'a
val fold_string: (string -> 'a -> 'a) -> string -> 'a -> 'a
val foldl1: ('a * 'a -> 'a) -> 'a list -> 'a
val foldr1: ('a * 'a -> 'a) -> 'a list -> 'a
val forall: ('a -> bool) -> 'a list -> bool
val forall_string: (string -> bool) -> string -> bool
val fst: 'a * 'b -> 'a
val funpow: int -> ('a -> 'a) -> 'a -> 'a
val funpow_yield: int -> ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val get_first: ('a -> 'b option) -> 'a list -> 'b option
val get_index: ('a -> 'b option) -> 'a list -> (int * 'b) option
val getenv: string -> string
val getenv_strict: string -> string
val grouped:
int ->
(('a list -> 'b list) -> 'c list list -> 'd list list) ->
('a -> 'b) -> 'c list -> 'd list
val has_duplicates: ('a * 'a -> bool) -> 'a list -> bool
val insert: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val int_ord: int * int -> order
val inter: ('a * 'b -> bool) -> 'b list -> 'a list -> 'a list
val is_equal: order -> bool
val is_prefix: ('a * 'a -> bool) -> 'a list -> 'a list -> bool
val list_ord: ('a * 'b -> order) -> 'a list * 'b list -> order
val make_ord: ('a * 'a -> bool) -> 'a * 'a -> order
val map2: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val map_filter: ('a -> 'b option) -> 'a list -> 'b list
val map_index: (int * 'a -> 'b) -> 'a list -> 'b list
val map_product: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val map_range: (int -> 'a) -> int -> 'a list
val map_split: ('a -> 'b * 'c) -> 'a list -> 'b list * 'c list
val map_transpose: ('a list -> 'b) -> 'a list list -> 'b list
val maps: ('a -> 'b list) -> 'a list -> 'b list
val match_string: string -> string -> bool
val member: ('a * 'b -> bool) -> 'b list -> 'a -> bool
val merge: ('a * 'a -> bool) -> 'a list * 'a list -> 'a list
val not_equal: ''a -> ''a -> bool
val nth: 'a list -> int -> 'a
val nth_drop: int -> 'a list -> 'a list
val nth_list: 'a list list -> int -> 'a list
val nth_map: int -> ('a -> 'a) -> 'a list -> 'a list
val nth_string: string -> int -> string
val oct_char: string -> string
val oo: ('a -> 'b) * ('c -> 'd -> 'a) -> 'c -> 'd -> 'b
val ooo: ('a -> 'b) * ('c -> 'd -> 'e -> 'a) -> 'c -> 'd -> 'e -> 'b
val oooo:
('a -> 'b) * ('c -> 'd -> 'e -> 'f -> 'a) ->
'c -> 'd -> 'e -> 'f -> 'b
val option_ord: ('a * 'b -> order) -> 'a option * 'b option -> order
val order_list: (int * 'a) list -> 'a list
val orf: ('a -> bool) * ('a -> bool) -> 'a -> bool
val pair: 'a -> 'b -> 'a * 'b
val partition_eq: ('a * 'a -> bool) -> 'a list -> 'a list list
val partition_list:
(int -> 'a -> bool) -> int -> int -> 'a list -> 'a list list
val perhaps_apply: ('a -> 'a option) list -> 'a -> 'a option
val perhaps_loop: ('a -> 'a option) -> 'a -> 'a option
val plain_words: string -> string
val prefix: string -> string -> string
val prefix_lines: string -> string -> string
val prefixes: 'a list -> 'a list list
val prefixes1: 'a list -> 'a list list
val prod_ord:
('a * 'b -> order) ->
('c * 'd -> order) -> ('a * 'c) * ('b * 'd) -> order
val quote: string -> string
val radixpand: int * int -> int list
val radixstring: int * string * int -> string
val read_int: string list -> int * string list
val read_radix_int: int -> string list -> int * string list
val remove: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val remove1: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val replicate: int -> 'a -> 'a list
val replicate_string: int -> string -> string
val rev_order: order -> order
val rpair: 'a -> 'b -> 'b * 'a
val separate: 'a -> 'a list -> 'a list
val serial: unit -> serial
eqtype serial
val serial_string: unit -> string
val signed_string_of_int: int -> string
val signed_string_of_real: real -> string
val single: 'a -> 'a list
val singleton: ('a list -> 'b list) -> 'a -> 'b
val snd: 'a * 'b -> 'b
val sort: ('a * 'a -> order) -> 'a list -> 'a list
val sort_by: ('a -> string) -> 'a list -> 'a list
val sort_distinct: ('a * 'a -> order) -> 'a list -> 'a list
val sort_strings: string list -> string list
val space_explode: string -> string -> string list
val space_implode: string -> string list -> string
val split_last: 'a list -> 'a list * 'a
val split_lines: string -> string list
val split_list: ('a * 'b) list -> 'a list * 'b list
val stamp: unit -> stamp
eqtype stamp
val string_of_indexname: string * int -> string
val string_of_int: int -> string
val string_of_real: real -> string
val string_ord: string * string -> order
val submultiset: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val subset: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val subtract: ('a * 'b -> bool) -> 'a list -> 'b list -> 'b list
val suffix: string -> string -> string
val suffixes: 'a list -> 'a list list
val suffixes1: 'a list -> 'a list list
val surround: 'a -> 'a list -> 'a list
val swap: 'a * 'b -> 'b * 'a
val tag_list: int -> 'a list -> (int * 'a) list
val take: int -> 'a list -> 'a list
val take_prefix: ('a -> bool) -> 'a list -> 'a list * 'a list
val take_suffix: ('a -> bool) -> 'a list -> 'a list * 'a list
val the_single: 'a list -> 'a
val translate_string: (string -> string) -> string -> string
val trim: ('a -> bool) -> 'a list -> 'a list
val trim_line: string -> string
val trim_split_lines: string -> string list
val uncurry: ('a -> 'b -> 'c) -> 'a * 'b -> 'c
val undefined: 'a -> 'b
val unenclose: string -> string
val unflat: 'a list list -> 'b list -> 'b list list
val union: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val unprefix: string -> string -> string
val unsuffix: string -> string -> string
val untag_list: (int * 'a) list -> 'a list
val update: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val upto: int * int -> int list
val yield_singleton:
('a list -> 'b -> 'c list * 'b) -> 'a -> 'b -> 'c * 'b
val zip_options: 'a list -> 'b option list -> ('a * 'b) list
val ~~: 'a list * 'b list -> ('a * 'b) list
end
signature LIBRARY =
sig
val ?: bool * ('a -> 'a) -> 'a -> 'a
structure Any: sig type T end
val I: 'a -> 'a
val K: 'a -> 'b -> 'a
val align_right: string -> int -> string -> string
val andf: ('a -> bool) * ('a -> bool) -> 'a -> bool
val apfst: ('a -> 'b) -> 'a * 'c -> 'b * 'c
val apply2: ('a -> 'b) -> 'a * 'a -> 'b * 'b
val apsnd: ('a -> 'b) -> 'c * 'a -> 'c * 'b
val bool_ord: bool * bool -> order
val burrow: ('a list -> 'b list) -> 'a list list -> 'b list list
val burrow_fst: ('a list -> 'b list) -> ('a * 'c) list -> ('b * 'c) list
val burrow_options:
('a list -> 'b list) -> 'a option list -> 'b option list
val cartouche: string -> string
val cat_lines: string list -> string
val chop: int -> 'a list -> 'a list * 'a list
val chop_groups: int -> 'a list -> 'a list list
val chop_prefix:
('a * 'b -> bool) ->
'a list * 'b list -> 'a list * ('a list * 'b list)
val combine: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val commas: string list -> string
val commas_quote: string list -> string
val curry: ('a * 'b -> 'c) -> 'a -> 'b -> 'c
val decode_lines: string -> string
val dict_ord: ('a * 'b -> order) -> 'a list * 'b list -> order
val distinct: ('a * 'a -> bool) -> 'a list -> 'a list
val divide_and_conquer: ('a -> 'a list * ('b list -> 'b)) -> 'a -> 'b
val divide_and_conquer':
('a -> 'b -> ('a list * ('c list * 'b -> 'c * 'b)) * 'b) ->
'a -> 'b -> 'c * 'b
val downto: int * int -> int list
val drop: int -> 'a list -> 'a list
val duplicates: ('a * 'a -> bool) -> 'a list -> 'a list
val enclose: string -> string -> string -> string
val encode_lines: string -> string
val eq_fst: ('a * 'b -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val eq_list: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val eq_pair:
('a * 'b -> bool) ->
('c * 'd -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val eq_set: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val eq_snd: ('a * 'b -> bool) -> ('c * 'a) * ('d * 'b) -> bool
val equal: ''a -> ''a -> bool
val exists: ('a -> bool) -> 'a list -> bool
val exists_string: (string -> bool) -> string -> bool
val fast_string_ord: string * string -> order
val filter: ('a -> bool) -> 'a list -> 'a list
val filter_out: ('a -> bool) -> 'a list -> 'a list
val find_first: ('a -> bool) -> 'a list -> 'a option
val find_index: ('a -> bool) -> 'a list -> int
val first_field: string -> string -> (string * string) option
val flat: 'a list list -> 'a list
val fold2: ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val fold_burrow:
('a list -> 'b -> 'c list * 'd) ->
'a list list -> 'b -> 'c list list * 'd
val fold_index: (int * 'a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val fold_product:
('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val fold_range: (int -> 'a -> 'a) -> int -> 'a -> 'a
val fold_string: (string -> 'a -> 'a) -> string -> 'a -> 'a
val foldl: ('a * 'b -> 'a) -> 'a * 'b list -> 'a
val foldl1: ('a * 'a -> 'a) -> 'a list -> 'a
val foldr: ('a * 'b -> 'b) -> 'a list * 'b -> 'b
val foldr1: ('a * 'a -> 'a) -> 'a list -> 'a
val forall: ('a -> bool) -> 'a list -> bool
val forall_string: (string -> bool) -> string -> bool
val fst: 'a * 'b -> 'a
val funpow: int -> ('a -> 'a) -> 'a -> 'a
val funpow_yield: int -> ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val get_first: ('a -> 'b option) -> 'a list -> 'b option
val get_index: ('a -> 'b option) -> 'a list -> (int * 'b) option
val getenv: string -> string
val getenv_strict: string -> string
val grouped:
int ->
(('a list -> 'b list) -> 'c list list -> 'd list list) ->
('a -> 'b) -> 'c list -> 'd list
val has_duplicates: ('a * 'a -> bool) -> 'a list -> bool
val insert: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val int_ord: int * int -> order
val inter: ('a * 'b -> bool) -> 'b list -> 'a list -> 'a list
val is_equal: order -> bool
val is_prefix: ('a * 'a -> bool) -> 'a list -> 'a list -> bool
val list_ord: ('a * 'b -> order) -> 'a list * 'b list -> order
val make_ord: ('a * 'a -> bool) -> 'a * 'a -> order
val map2: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val map_filter: ('a -> 'b option) -> 'a list -> 'b list
val map_index: (int * 'a -> 'b) -> 'a list -> 'b list
val map_product: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val map_range: (int -> 'a) -> int -> 'a list
val map_split: ('a -> 'b * 'c) -> 'a list -> 'b list * 'c list
val map_transpose: ('a list -> 'b) -> 'a list list -> 'b list
val maps: ('a -> 'b list) -> 'a list -> 'b list
val match_string: string -> string -> bool
val member: ('a * 'b -> bool) -> 'b list -> 'a -> bool
val merge: ('a * 'a -> bool) -> 'a list * 'a list -> 'a list
val not_equal: ''a -> ''a -> bool
val nth: 'a list -> int -> 'a
val nth_drop: int -> 'a list -> 'a list
val nth_list: 'a list list -> int -> 'a list
val nth_map: int -> ('a -> 'a) -> 'a list -> 'a list
val nth_string: string -> int -> string
val oct_char: string -> string
val oo: ('a -> 'b) * ('c -> 'd -> 'a) -> 'c -> 'd -> 'b
val ooo: ('a -> 'b) * ('c -> 'd -> 'e -> 'a) -> 'c -> 'd -> 'e -> 'b
val oooo:
('a -> 'b) * ('c -> 'd -> 'e -> 'f -> 'a) ->
'c -> 'd -> 'e -> 'f -> 'b
val option_ord: ('a * 'b -> order) -> 'a option * 'b option -> order
val order_list: (int * 'a) list -> 'a list
val orf: ('a -> bool) * ('a -> bool) -> 'a -> bool
val pair: 'a -> 'b -> 'a * 'b
val partition_eq: ('a * 'a -> bool) -> 'a list -> 'a list list
val partition_list:
(int -> 'a -> bool) -> int -> int -> 'a list -> 'a list list
val perhaps_apply: ('a -> 'a option) list -> 'a -> 'a option
val perhaps_loop: ('a -> 'a option) -> 'a -> 'a option
val plain_words: string -> string
val prefix: string -> string -> string
val prefix_lines: string -> string -> string
val prefixes: 'a list -> 'a list list
val prefixes1: 'a list -> 'a list list
val prod_ord:
('a * 'b -> order) ->
('c * 'd -> order) -> ('a * 'c) * ('b * 'd) -> order
val quote: string -> string
val radixpand: int * int -> int list
val radixstring: int * string * int -> string
val read_int: string list -> int * string list
val read_radix_int: int -> string list -> int * string list
val remove: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val remove1: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val replicate: int -> 'a -> 'a list
val replicate_string: int -> string -> string
val rev_order: order -> order
val rpair: 'a -> 'b -> 'b * 'a
val separate: 'a -> 'a list -> 'a list
val serial: unit -> serial
eqtype serial
val serial_string: unit -> string
val signed_string_of_int: int -> string
val signed_string_of_real: real -> string
val single: 'a -> 'a list
val singleton: ('a list -> 'b list) -> 'a -> 'b
val snd: 'a * 'b -> 'b
val sort: ('a * 'a -> order) -> 'a list -> 'a list
val sort_by: ('a -> string) -> 'a list -> 'a list
val sort_distinct: ('a * 'a -> order) -> 'a list -> 'a list
val sort_strings: string list -> string list
val space_explode: string -> string -> string list
val space_implode: string -> string list -> string
val split_last: 'a list -> 'a list * 'a
val split_lines: string -> string list
val split_list: ('a * 'b) list -> 'a list * 'b list
val stamp: unit -> stamp
eqtype stamp
val string_of_indexname: string * int -> string
val string_of_int: int -> string
val string_of_real: real -> string
val string_ord: string * string -> order
val submultiset: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val subset: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val subtract: ('a * 'b -> bool) -> 'a list -> 'b list -> 'b list
val suffix: string -> string -> string
val suffixes: 'a list -> 'a list list
val suffixes1: 'a list -> 'a list list
val surround: 'a -> 'a list -> 'a list
val swap: 'a * 'b -> 'b * 'a
val tag_list: int -> 'a list -> (int * 'a) list
val take: int -> 'a list -> 'a list
val take_prefix: ('a -> bool) -> 'a list -> 'a list * 'a list
val take_suffix: ('a -> bool) -> 'a list -> 'a list * 'a list
val the_single: 'a list -> 'a
val translate_string: (string -> string) -> string -> string
val trim: ('a -> bool) -> 'a list -> 'a list
val trim_line: string -> string
val trim_split_lines: string -> string list
val uncurry: ('a -> 'b -> 'c) -> 'a * 'b -> 'c
val undefined: 'a -> 'b
val unenclose: string -> string
val unflat: 'a list list -> 'b list -> 'b list list
val union: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val unprefix: string -> string -> string
val unsuffix: string -> string -> string
val untag_list: (int * 'a) list -> 'a list
val update: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val upto: int * int -> int list
val yield_singleton:
('a list -> 'b -> 'c list * 'b) -> 'a -> 'b -> 'c * 'b
val zip_options: 'a list -> 'b option list -> ('a * 'b) list
val ~~: 'a list * 'b list -> ('a * 'b) list
end
Warning: Value identifier (y) has not been referenced.
At (line 256 of "library.ML")
Warning: Value identifier (x) has not been referenced.
At (line 257 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 334 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 339 of "library.ML")
Warning: Matches are not exhaustive.
fun itr [x] = x | itr (... :: ...) = f (...)
At (line 341 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 355 of "library.ML")
Warning: Value identifier (xs) has not been referenced.
At (line 362 of "library.ML")
Warning: Value identifier (x) has not been referenced.
At (line 368 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 485 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 484 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 489 of "library.ML")
Warning: Value identifier (f) has not been referenced.
At (line 488 of "library.ML")
Warning: Value identifier (eq) has not been referenced.
At (line 532 of "library.ML")
Warning: Value identifier (eq) has not been referenced.
At (line 543 of "library.ML")
Warning: Value identifier (eq) has not been referenced.
At (line 542 of "library.ML")
Warning: Value identifier (x) has not been referenced.
At (line 841 of "library.ML")
Warning: Value identifier (eq) has not been referenced.
At (line 841 of "library.ML")
Warning: Value identifier (k) has not been referenced.
At (line 957 of "library.ML")
Warning: Value identifier (x') has not been referenced.
At (line 963 of "library.ML")
Warning: Value identifier (k) has not been referenced.
At (line 962 of "library.ML")
structure Library: LIBRARY
structure Basic_Library: BASIC_LIBRARY
eqtype serial
eqtype stamp
structure Any: sig type T end
val string_of_real = fn: real -> string
val equal = fn: ''a -> ''a -> bool
val order_list = fn: (int * 'a) list -> 'a list
val funpow_yield = fn: int -> ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val trim_split_lines = fn: string -> string list
val suffixes = fn: 'a list -> 'a list list
val quote = fn: string -> string
val eq_fst = fn: ('a * 'b -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val commas = fn: string list -> string
val snd = fn: 'a * 'b -> 'b
val the_single = fn: 'a list -> 'a
val prefix = fn: string -> string -> string
val partition_eq = fn: ('a * 'a -> bool) -> 'a list -> 'a list list
val inter = fn: ('a * 'b -> bool) -> 'b list -> 'a list -> 'a list
val cat_lines = fn: string list -> string
val map_index = fn: (int * 'a -> 'b) -> 'a list -> 'b list
val align_right = fn: string -> int -> string -> string
val take = fn: int -> 'a list -> 'a list
val eq_snd = fn: ('a * 'b -> bool) -> ('c * 'a) * ('d * 'b) -> bool
val ~~ = fn: 'a list * 'b list -> ('a * 'b) list
val downto = fn: int * int -> int list
val union = fn: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val translate_string = fn: (string -> string) -> string -> string
val update = fn: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val match_string = fn: string -> string -> bool
val radixstring = fn: int * string * int -> string
val separate = fn: 'a -> 'a list -> 'a list
val signed_string_of_int = fn: int -> string
val ? = fn: bool * ('a -> 'a) -> 'a -> 'a
val suffixes1 = fn: 'a list -> 'a list list
val map2 = fn: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_order = fn: order -> order
val nth_list = fn: 'a list list -> int -> 'a list
val uncurry = fn: ('a -> 'b -> 'c) -> 'a * 'b -> 'c
val fold_product = fn:
('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val merge = fn: ('a * 'a -> bool) -> 'a list * 'a list -> 'a list
val I = fn: 'a -> 'a
val subtract = fn: ('a * 'b -> bool) -> 'a list -> 'b list -> 'b list
val K = fn: 'a -> 'b -> 'a
val fold_index = fn: (int * 'a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val map_transpose = fn: ('a list -> 'b) -> 'a list list -> 'b list
val nth_map = fn: int -> ('a -> 'a) -> 'a list -> 'a list
val string_ord = fn: string * string -> order
val has_duplicates = fn: ('a * 'a -> bool) -> 'a list -> bool
val replicate_string = fn: int -> string -> string
val remove = fn: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val remove1 = fn: ('a * 'b -> bool) -> 'a -> 'b list -> 'b list
val suffix = fn: string -> string -> string
val zip_options = fn: 'a list -> 'b option list -> ('a * 'b) list
val perhaps_apply = fn: ('a -> 'a option) list -> 'a -> 'a option
val submultiset = fn: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val nth_string = fn: string -> int -> string
val andf = fn: ('a -> bool) * ('a -> bool) -> 'a -> bool
val string_of_indexname = fn: string * int -> string
val unprefix = fn: string -> string -> string
val read_int = fn: string list -> int * string list
val undefined = fn: 'a -> 'b
val not_equal = fn: ''a -> ''a -> bool
val take_prefix = fn: ('a -> bool) -> 'a list -> 'a list * 'a list
val foldl1 = fn: ('a * 'a -> 'a) -> 'a list -> 'a
val prod_ord = fn:
('a * 'b -> order) -> ('c * 'd -> order) -> ('a * 'c) * ('b * 'd) -> order
val curry = fn: ('a * 'b -> 'c) -> 'a -> 'b -> 'c
val foldr1 = fn: ('a * 'a -> 'a) -> 'a list -> 'a
val find_index = fn: ('a -> bool) -> 'a list -> int
val filter_out = fn: ('a -> bool) -> 'a list -> 'a list
val map_filter = fn: ('a -> 'b option) -> 'a list -> 'b list
val eq_pair = fn:
('a * 'b -> bool) -> ('c * 'd -> bool) -> ('a * 'c) * ('b * 'd) -> bool
val getenv = fn: string -> string
val dict_ord = fn: ('a * 'b -> order) -> 'a list * 'b list -> order
val make_ord = fn: ('a * 'a -> bool) -> 'a * 'a -> order
val orf = fn: ('a -> bool) * ('a -> bool) -> 'a -> bool
val map_product = fn: ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val burrow = fn: ('a list -> 'b list) -> 'a list list -> 'b list list
val space_explode = fn: string -> string -> string list
val enclose = fn: string -> string -> string -> string
val take_suffix = fn: ('a -> bool) -> 'a list -> 'a list * 'a list
val yield_singleton = fn:
('a list -> 'b -> 'c list * 'b) -> 'a -> 'b -> 'c * 'b
val map_range = fn: (int -> 'a) -> int -> 'a list
val unflat = fn: 'a list list -> 'b list -> 'b list list
val insert = fn: ('a * 'a -> bool) -> 'a -> 'a list -> 'a list
val divide_and_conquer' = fn:
('a -> 'b -> ('a list * ('c list * 'b -> 'c * 'b)) * 'b) ->
'a -> 'b -> 'c * 'b
val surround = fn: 'a -> 'a list -> 'a list
val split_list = fn: ('a * 'b) list -> 'a list * 'b list
val fast_string_ord = fn: string * string -> order
val singleton = fn: ('a list -> 'b list) -> 'a -> 'b
val subset = fn: ('a * 'b -> bool) -> 'a list * 'b list -> bool
val unsuffix = fn: string -> string -> string
val find_first = fn: ('a -> bool) -> 'a list -> 'a option
val is_prefix = fn: ('a * 'a -> bool) -> 'a list -> 'a list -> bool
val sort_by = fn: ('a -> string) -> 'a list -> 'a list
val decode_lines = fn: string -> string
val upto = fn: int * int -> int list
val rpair = fn: 'a -> 'b -> 'b * 'a
val commas_quote = fn: string list -> string
val untag_list = fn: (int * 'a) list -> 'a list
val sort = fn: ('a * 'a -> order) -> 'a list -> 'a list
val cartouche = fn: string -> string
val apsnd = fn: ('a -> 'b) -> 'c * 'a -> 'c * 'b
val signed_string_of_real = fn: real -> string
val plain_words = fn: string -> string
val member = fn: ('a * 'b -> bool) -> 'b list -> 'a -> bool
val grouped = fn:
int ->
(('a list -> 'b list) -> 'c list list -> 'd list list) ->
('a -> 'b) -> 'c list -> 'd list
val fst = fn: 'a * 'b -> 'a
val option_ord = fn: ('a * 'b -> order) -> 'a option * 'b option -> order
val fold2 = fn: ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val chop = fn: int -> 'a list -> 'a list * 'a list
val apply2 = fn: ('a -> 'b) -> 'a * 'a -> 'b * 'b
val tag_list = fn: int -> 'a list -> (int * 'a) list
val exists = fn: ('a -> bool) -> 'a list -> bool
val string_of_int = fn: int -> string
val combine = fn: ('a * 'a -> bool) -> 'a list -> 'a list -> 'a list
val is_equal = fn: order -> bool
val map_split = fn: ('a -> 'b * 'c) -> 'a list -> 'b list * 'c list
val getenv_strict = fn: string -> string
val eq_list = fn: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val serial = fn: unit -> serial
val sort_strings = fn: string list -> string list
val funpow = fn: int -> ('a -> 'a) -> 'a -> 'a
val divide_and_conquer = fn: ('a -> 'a list * ('b list -> 'b)) -> 'a -> 'b
val trim_line = fn: string -> string
val oct_char = fn: string -> string
val radixpand = fn: int * int -> int list
val exists_string = fn: (string -> bool) -> string -> bool
val chop_groups = fn: int -> 'a list -> 'a list list
val pair = fn: 'a -> 'b -> 'a * 'b
val fold_string = fn: (string -> 'a -> 'a) -> string -> 'a -> 'a
val oooo = fn:
('a -> 'b) * ('c -> 'd -> 'e -> 'f -> 'a) -> 'c -> 'd -> 'e -> 'f -> 'b
val fold_range = fn: (int -> 'a -> 'a) -> int -> 'a -> 'a
val encode_lines = fn: string -> string
val read_radix_int = fn: int -> string list -> int * string list
val trim = fn: ('a -> bool) -> 'a list -> 'a list
val ooo = fn: ('a -> 'b) * ('c -> 'd -> 'e -> 'a) -> 'c -> 'd -> 'e -> 'b
val oo = fn: ('a -> 'b) * ('c -> 'd -> 'a) -> 'c -> 'd -> 'b
val split_lines = fn: string -> string list
val distinct = fn: ('a * 'a -> bool) -> 'a list -> 'a list
val partition_list = fn:
(int -> 'a -> bool) -> int -> int -> 'a list -> 'a list list
val space_implode = fn: string -> string list -> string
val filter = fn: ('a -> bool) -> 'a list -> 'a list
val get_index = fn: ('a -> 'b option) -> 'a list -> (int * 'b) option
val nth = fn: 'a list -> int -> 'a
val serial_string = fn: unit -> string
val get_first = fn: ('a -> 'b option) -> 'a list -> 'b option
val prefixes = fn: 'a list -> 'a list list
val fold_burrow = fn:
('a list -> 'b -> 'c list * 'd) -> 'a list list -> 'b -> 'c list list * 'd
val drop = fn: int -> 'a list -> 'a list
val bool_ord = fn: bool * bool -> order
val swap = fn: 'a * 'b -> 'b * 'a
val flat = fn: 'a list list -> 'a list
val forall = fn: ('a -> bool) -> 'a list -> bool
val maps = fn: ('a -> 'b list) -> 'a list -> 'b list
val chop_prefix = fn:
('a * 'b -> bool) -> 'a list * 'b list -> 'a list * ('a list * 'b list)
val sort_distinct = fn: ('a * 'a -> order) -> 'a list -> 'a list
val unenclose = fn: string -> string
val burrow_options = fn:
('a list -> 'b list) -> 'a option list -> 'b option list
val stamp = fn: unit -> stamp
val first_field = fn: string -> string -> (string * string) option
val burrow_fst = fn: ('a list -> 'b list) -> ('a * 'c) list -> ('b * 'c) list
val split_last = fn: 'a list -> 'a list * 'a
val list_ord = fn: ('a * 'b -> order) -> 'a list * 'b list -> order
val forall_string = fn: (string -> bool) -> string -> bool
val single = fn: 'a -> 'a list
val eq_set = fn: ('a * 'a -> bool) -> 'a list * 'a list -> bool
val prefix_lines = fn: string -> string -> string
val int_ord = fn: int * int -> order
val prefixes1 = fn: 'a list -> 'a list list
val replicate = fn: int -> 'a -> 'a list
val nth_drop = fn: int -> 'a list -> 'a list
val duplicates = fn: ('a * 'a -> bool) -> 'a list -> 'a list
val perhaps_loop = fn: ('a -> 'a option) -> 'a -> 'a option
val apfst = fn: ('a -> 'b) -> 'a * 'c -> 'b * 'c
val it = (): unit
signature BASIC_PRINT_MODE =
sig
val print_mode: string list ref
val print_mode_active: string -> bool
val print_mode_value: unit -> string list
end
signature PRINT_MODE =
sig
val ASCII: string
val add_modes: string list -> unit
val closure: ('a -> 'b) -> 'a -> 'b
val input: string
val internal: string
val print_mode: string list ref
val print_mode_active: string -> bool
val print_mode_value: unit -> string list
val setmp: string list -> ('a -> 'b) -> 'a -> 'b
val with_modes: string list -> ('a -> 'b) -> 'a -> 'b
end
structure Print_Mode: PRINT_MODE
structure Basic_Print_Mode: BASIC_PRINT_MODE
val print_mode_value = fn: unit -> string list
val print_mode = ref []: string list ref
val print_mode_active = fn: string -> bool
val it = (): unit
signature ALIST =
sig
exception DUP
val coalesce: ('a * 'a -> bool) -> ('a * 'b) list -> ('a * 'b list) list
val default:
('a * 'a -> bool) -> 'a * 'b -> ('a * 'b) list -> ('a * 'b) list
val defined: ('a * 'b -> bool) -> ('b * 'c) list -> 'a -> bool
val delete: ('a * 'b -> bool) -> 'a -> ('b * 'c) list -> ('b * 'c) list
val find: ('a * 'b -> bool) -> ('c * 'b) list -> 'a -> 'c list
val group: ('a * 'a -> bool) -> ('a * 'b) list -> ('a * 'b list) list
val join:
('a * 'a -> bool) ->
('a -> 'b * 'b -> 'b) ->
('a * 'b) list * ('a * 'b) list -> ('a * 'b) list
val lookup: ('a * 'b -> bool) -> ('b * 'c) list -> 'a -> 'c option
val make: ('a -> 'b) -> 'a list -> ('a * 'b) list
val map_default:
('a * 'a -> bool) ->
'a * 'b -> ('b -> 'b) -> ('a * 'b) list -> ('a * 'b) list
val map_entry:
('a * 'b -> bool) ->
'a -> ('c -> 'c) -> ('b * 'c) list -> ('b * 'c) list
val map_entry_yield:
('a * 'b -> bool) ->
'a ->
('c -> 'd * 'c) -> ('b * 'c) list -> 'd option * ('b * 'c) list
val merge:
('a * 'a -> bool) ->
('b * 'b -> bool) ->
('a * 'b) list * ('a * 'b) list -> ('a * 'b) list
val update:
('a * 'a -> bool) -> 'a * 'b -> ('a * 'b) list -> ('a * 'b) list
end
Warning: Value identifier (value) has not been referenced.
At (line 41 of "General/alist.ML")
Warning: Matches are not exhaustive.
fun mapp 0 (... :: ...) = f_some x xs | mapp i ... = x :: ... ...
At (line 50 of "General/alist.ML")
Warning: Value identifier (value) has not been referenced.
At (line 60 of "General/alist.ML")
Warning: Value identifier (value) has not been referenced.
At (line 63 of "General/alist.ML")
Warning: Value identifier (x) has not been referenced.
At (line 81 of "General/alist.ML")
Warning: Matches are not exhaustive.
fun
mapp 0 (... :: ...) = let val ... = ... in (... ..., ...) end |
mapp i ... = let val ... in (...) end
At (line 81 of "General/alist.ML")
Warning: Value identifier (eq) has not been referenced.
At (line 106 of "General/alist.ML")
structure AList: ALIST
val it = (): unit
signature KEY = sig type key val ord: key * key -> order end
signature TABLE =
sig
exception DUP of key
exception SAME
exception UNDEF of key
val cons_list: key * 'a -> 'a list table -> 'a list table
val default: key * 'a -> 'a table -> 'a table
val defined: 'a table -> key -> bool
val delete: key -> 'a table -> 'a table
val delete_safe: key -> 'a table -> 'a table
val dest: 'a table -> (key * 'a) list
val dest_list: 'a list table -> (key * 'a) list
val empty: 'a table
val exists: (key * 'a -> bool) -> 'a table -> bool
val fold: (key * 'a -> 'b -> 'b) -> 'a table -> 'b -> 'b
val fold_rev: (key * 'a -> 'b -> 'b) -> 'a table -> 'b -> 'b
val forall: (key * 'a -> bool) -> 'a table -> bool
val get_first: (key * 'a -> 'b option) -> 'a table -> 'b option
val insert: ('a * 'a -> bool) -> key * 'a -> 'a table -> 'a table
val insert_list:
('a * 'a -> bool) -> key * 'a -> 'a list table -> 'a list table
val insert_set: key -> set -> set
val is_empty: 'a table -> bool
val join: (key -> 'a * 'a -> 'a) -> 'a table * 'a table -> 'a table
type key
val keys: 'a table -> key list
val lookup: 'a table -> key -> 'a option
val lookup_key: 'a table -> key -> (key * 'a) option
val lookup_list: 'a list table -> key -> 'a list
val make: (key * 'a) list -> 'a table
val make_list: (key * 'a) list -> 'a list table
val make_set: key list -> set
val map: (key -> 'a -> 'b) -> 'a table -> 'b table
val map_default: key * 'a -> ('a -> 'a) -> 'a table -> 'a table
val map_entry: key -> ('a -> 'a) -> 'a table -> 'a table
val max: 'a table -> (key * 'a) option
val member: ('a * 'b -> bool) -> 'b table -> key * 'a -> bool
val merge: ('a * 'a -> bool) -> 'a table * 'a table -> 'a table
val merge_list:
('a * 'a -> bool) -> 'a list table * 'a list table -> 'a list table
val min: 'a table -> (key * 'a) option
val remove: ('a * 'b -> bool) -> key * 'a -> 'b table -> 'b table
val remove_list:
('a * 'b -> bool) -> key * 'a -> 'b list table -> 'b list table
type set = unit table
type 'a table
val update: key * 'a -> 'a table -> 'a table
val update_list:
('a * 'a -> bool) -> key * 'a -> 'a list table -> 'a list table
val update_new: key * 'a -> 'a table -> 'a table
end
Warning: Value identifier (x2) has not been referenced.
At (line 197 of "General/table.ML")
Warning: Value identifier (x1) has not been referenced.
At (line 197 of "General/table.ML")
Warning: Value identifier (x) has not been referenced.
At (line 192 of "General/table.ML")
Warning: Value identifier (k2) has not been referenced.
At (line 274 of "General/table.ML")
Warning: Value identifier (x) has not been referenced.
At (line 278 of "General/table.ML")
Warning: Value identifier (y) has not been referenced.
At (line 277 of "General/table.ML")
Warning: Matches are not exhaustive.
case (m, r) of
(Branch2 (ml, ...), Branch2 _) => Branch2 (Branch3 (...), q, ...) |
(Branch3 (...), _) => Branch3 (... ..., ...) |
(... ..., ...) => Branch3 (...)
At (line 311 of "General/table.ML")
Warning: Matches are not exhaustive.
case (l, r) of
(Branch2 (ll, ...), Branch2 _) => Branch2 (Branch3 (...), q, ...) |
(Branch3 (...), _) => Branch3 (... ..., ...) |
(_, ...) => Branch3 (...)
At (line 322 of "General/table.ML")
Warning: Matches are not exhaustive.
case (l, m) of
(Branch2 _, Branch2 (...)) => Branch2 (l, p, ...) |
(_, ... ...) => Branch3 (l, ...) |
(... ..., ...) => Branch3 (...)
At (line 334 of "General/table.ML")
Warning: Matches are not exhaustive.
case r of
Branch2 (rl, rp, ...) => (true, Branch3 (...)) |
Branch3 (rl, ...) => (false, ... ...)
At (line 295 of "General/table.ML")
Warning: Matches are not exhaustive.
case l of
Branch2 (ll, lp, ...) => (true, Branch3 (...)) |
Branch3 (ll, ...) => (false, ... ...)
At (line 302 of "General/table.ML")
Warning: Matches are not exhaustive.
case (m, r) of
(Branch2 (ml, ...), Branch2 _) => Branch2 (Branch3 (...), q, ...) |
(Branch3 (...), _) => Branch3 (... ..., ...) |
(... ..., ...) => Branch3 (...)
At (line 311 of "General/table.ML")
Warning: Matches are not exhaustive.
case (l, r) of
(Branch2 (ll, ...), Branch2 _) => Branch2 (Branch3 (...), q, ...) |
(Branch3 (...), _) => Branch3 (... ..., ...) |
(_, ...) => Branch3 (...)
At (line 322 of "General/table.ML")
Warning: Matches are not exhaustive.
case (l, m) of
(Branch2 _, Branch2 (...)) => Branch2 (l, p, ...) |
(_, ... ...) => Branch3 (l, ...) |
(... ..., ...) => Branch3 (...)
At (line 334 of "General/table.ML")
Warning: Matches are not exhaustive.
case r of
Branch2 (rl, rp, ...) => (true, Branch3 (...)) |
Branch3 (rl, ...) => (false, ... ...)
At (line 295 of "General/table.ML")
Warning: Matches are not exhaustive.
case l of
Branch2 (ll, lp, ...) => (true, Branch3 (...)) |
Branch3 (ll, ...) => (false, ... ...)
At (line 302 of "General/table.ML")
Warning: Matches are not exhaustive.
fun
del (SOME k) Empty = raise UNDEF k |
del NONE ... = (p, ...) |
del ... = (...) |
del ... = ... |
...
At (line 280 of "General/table.ML")
functor Table (Key: KEY): TABLE
structure Inttab: TABLE
structure Symtab: TABLE
structure Symreltab: TABLE
val it = (): unit
signature RANDOM =
sig
exception RANDOM
val random: unit -> real
val random_range: int -> int -> int
end
structure Random: RANDOM
val it = (): unit
signature VALUE =
sig
val parse_bool: string -> bool
val parse_int: string -> int
val parse_nat: string -> int
val parse_real: string -> real
val print_bool: bool -> string
val print_int: int -> string
val print_real: real -> string
end
structure Value: VALUE
val it = (): unit
signature PROPERTIES =
sig
type T = entry list
val defined: T -> string -> bool
type entry = string * string
val get: T -> string -> string option
val put: entry -> T -> T
val remove: string -> T -> T
val seconds: T -> string -> Time.time
end
structure Properties: PROPERTIES
val it = (): unit
signature BASIC_OUTPUT =
sig
val legacy_feature: string -> unit
val profile_allocations: ('a -> 'b) -> 'a -> 'b
val profile_time: ('a -> 'b) -> 'a -> 'b
val profile_time_thread: ('a -> 'b) -> 'a -> 'b
val tracing: string -> unit
val warning: string -> unit
val writeln: string -> unit
end
signature OUTPUT =
sig
exception Protocol_Message of Properties.T
val add_mode:
string -> (string -> output * int) -> (output -> string) -> unit
val default_escape: output -> string
val default_output: string -> output * int
val error_message: string -> unit
val error_message': serial * string -> unit
val escape: output -> string
val information: string -> unit
val legacy_feature: string -> unit
val output: string -> output
eqtype output
val output_width: string -> output * int
val physical_stderr: output -> unit
val physical_stdout: output -> unit
val physical_writeln: output -> unit
val profile_allocations: ('a -> 'b) -> 'a -> 'b
val profile_time: ('a -> 'b) -> 'a -> 'b
val profile_time_thread: ('a -> 'b) -> 'a -> 'b
val protocol_message: Properties.T -> string list -> unit
val report: string list -> unit
val result: Properties.T -> string list -> unit
val state: string -> unit
val status: string -> unit
val system_message: string -> unit
val tracing: string -> unit
val try_protocol_message: Properties.T -> string list -> unit
val warning: string -> unit
val writeln: string -> unit
val writelns: string list -> unit
end
signature PRIVATE_OUTPUT =
sig
exception Protocol_Message of Properties.T
val add_mode:
string -> (string -> output * int) -> (output -> string) -> unit
val default_escape: output -> string
val default_output: string -> output * int
val error_message: string -> unit
val error_message': serial * string -> unit
val error_message_fn: (serial * output list -> unit) ref
val escape: output -> string
val information: string -> unit
val information_fn: (output list -> unit) ref
val init_channels: unit -> unit
val legacy_feature: string -> unit
val legacy_fn: (output list -> unit) ref
val output: string -> output
eqtype output
val output_width: string -> output * int
val physical_stderr: output -> unit
val physical_stdout: output -> unit
val physical_writeln: output -> unit
val profile_allocations: ('a -> 'b) -> 'a -> 'b
val profile_time: ('a -> 'b) -> 'a -> 'b
val profile_time_thread: ('a -> 'b) -> 'a -> 'b
val protocol_message: Properties.T -> string list -> unit
val protocol_message_fn: (Properties.T -> output list -> unit) ref
val report: string list -> unit
val report_fn: (output list -> unit) ref
val result: Properties.T -> string list -> unit
val result_fn: (Properties.T -> output list -> unit) ref
val state: string -> unit
val state_fn: (output list -> unit) ref
val status: string -> unit
val status_fn: (output list -> unit) ref
val system_message: string -> unit
val system_message_fn: (output list -> unit) ref
val tracing: string -> unit
val tracing_fn: (output list -> unit) ref
val try_protocol_message: Properties.T -> string list -> unit
val warning: string -> unit
val warning_fn: (output list -> unit) ref
val writeln: string -> unit
val writeln_fn: (output list -> unit) ref
val writelns: string list -> unit
end
structure Private_Output: PRIVATE_OUTPUT
structure Output: OUTPUT
structure Basic_Output: BASIC_OUTPUT
val profile_time_thread = fn: ('a -> 'b) -> 'a -> 'b
val profile_time = fn: ('a -> 'b) -> 'a -> 'b
val profile_allocations = fn: ('a -> 'b) -> 'a -> 'b
val warning = fn: string -> unit
val tracing = fn: string -> unit
val writeln = fn: string -> unit
val legacy_feature = fn: string -> unit
val it = (): unit
signature MARKUP =
sig
val ML_antiquotationN: string
val ML_breakpoint: int -> T
val ML_breakpointN: string
val ML_char: T
val ML_charN: string
val ML_comment: T
val ML_commentN: string
val ML_defN: string
val ML_delimiter: T
val ML_delimiterN: string
val ML_keyword1: T
val ML_keyword1N: string
val ML_keyword2: T
val ML_keyword2N: string
val ML_keyword3: T
val ML_keyword3N: string
val ML_numeral: T
val ML_numeralN: string
val ML_openN: string
val ML_statistics: Properties.entry
val ML_string: T
val ML_stringN: string
val ML_structureN: string
val ML_tvar: T
val ML_tvarN: string
val ML_typing: T
val ML_typingN: string
val SML_comment: T
val SML_commentN: string
val SML_string: T
val SML_stringN: string
type T = string * Properties.T
val accepted: T
val acceptedN: string
val add_mode: string -> (T -> string * string) -> unit
val alt_string: T
val alt_stringN: string
val antiquote: T
val antiquoteN: string
val antiquoted: T
val antiquotedN: string
val assign_update: Properties.T
val bad: unit -> T
val badN: string
val binding: T
val bindingN: string
val block: bool -> int -> T
val blockN: string
val block_properties: string list
val bound: T
val boundN: string
val break: int -> int -> T
val breakN: string
val browserN: string
val build_session_finished: Properties.T
val cancel_scala: string -> Properties.T
val cartouche: T
val cartoucheN: string
val caseN: string
val case_: string -> T
val citation: string -> T
val citationN: string
val classN: string
val class_parameter: T
val class_parameterN: string
val commandN: string
val command_indent: int -> T
val command_indentN: string
val command_keyword: T
val command_keywordN: string
val command_properties: T -> T
val command_timing: Properties.entry
val command_timingN: string
val command_timing_properties:
{file: string, name: string, offset: int} -> Time.time -> Properties.T
val comment: T
val commentN: string
val completion: T
val completionN: string
val consistentN: string
val consolidated: T
val consolidatedN: string
val constantN: string
val cpuN: string
val debugger_output: string -> Properties.T
val debugger_state: string -> Properties.T
val defN: string
val delimitedN: string
val delimiter: T
val delimiterN: string
val dest_loading_theory: Properties.T -> string option
val dialog: serial -> string -> T
val dialogN: string
val doc: string -> T
val docN: string
val document_antiquotationN: string
val document_antiquotation_optionN: string
val dynamic_fact: string -> T
val dynamic_factN: string
val elapsedN: string
val empty: T
val enclose: T -> string -> string
val end_lineN: string
val end_offsetN: string
val entity: string -> string -> T
val entityN: string
val error: T
val errorN: string
val exec_idN: string
val expression: string -> T
val expressionN: string
val failed: T
val failedN: string
val fbreak: T
val fbreakN: string
val fileN: string
val finished: T
val finishedN: string
val fixed: string -> T
val fixedN: string
val forked: T
val forkedN: string
val free: T
val freeN: string
val functionN: string
val gcN: string
val get_entity_kind: T -> string option
val goal: T
val goalN: string
val graphviewN: string
val hidden: T
val hiddenN: string
val idN: string
val improper: T
val improperN: string
val indentN: string
val information: T
val informationN: string
val initN: string
val inner_cartouche: T
val inner_cartoucheN: string
val inner_comment: T
val inner_commentN: string
val inner_string: T
val inner_stringN: string
val input: bool -> Properties.T -> T
val inputN: string
val instanceN: string
val intensify: T
val intensifyN: string
val invoke_scala: string -> string -> Properties.T
val is_delimited: Properties.T -> bool
val is_empty: T -> bool
val item: T
val itemN: string
val jedit_actionN: string
val joined: T
val joinedN: string
val keyword1: T
val keyword1N: string
val keyword2: T
val keyword2N: string
val keyword3: T
val keyword3N: string
val keywordN: string
val keyword_properties: T -> T
val kindN: string
val language:
{antiquotes: bool, delimited: bool, name: string, symbols: bool} -> T
val language':
{antiquotes: bool, name: string, symbols: bool} -> bool -> T
val languageN: string
val language_Isar: bool -> T
val language_ML: bool -> T
val language_SML: bool -> T
val language_antiquotation: T
val language_attribute: T
val language_document: bool -> T
val language_method: T
val language_mixfix: T
val language_path: T
val language_prop: bool -> T
val language_rail: T
val language_sort: bool -> T
val language_term: bool -> T
val language_text: bool -> T
val language_type: bool -> T
val language_verbatim: bool -> T
val legacy: T
val legacyN: string
val lineN: string
val literal: T
val literalN: string
val literal_fact: string -> T
val literal_factN: string
val loading_theory: string -> Properties.T
val markdown_item: int -> T
val markdown_itemN: string
val markdown_list: string -> T
val markdown_listN: string
val markdown_paragraph: T
val markdown_paragraphN: string
val markup: T -> string -> string
val markupN: string
val markup_only: T -> string
val markup_report: string -> string
val markups: T list -> string -> string
val method_modifierN: string
val name: string -> T -> T
val nameN: string
val no_completion: T
val no_completionN: string
val no_output: string * string
val no_report: T
val no_reportN: string
val numeral: T
val numeralN: string
val offsetN: string
val operator: T
val operatorN: string
val output: T -> string * string
val paddingN: string
val padding_command: Properties.entry
val padding_line: Properties.entry
val paragraph: T
val paragraphN: string
val parse_command_timing_properties:
Properties.T ->
({file: string, name: string, offset: int} * Time.time) option
val parse_timing_properties:
Properties.T -> {cpu: Time.time, elapsed: Time.time, gc: Time.time}
val path: string -> T
val pathN: string
val position: T
val positionN: string
val position_properties: string list
val position_properties': string list
val print_operations: Properties.T
val print_operationsN: string
val properties: Properties.T -> T -> T
val protocolN: string
val protocol_handler: string -> Properties.T
val quasi_keyword: T
val quasi_keywordN: string
val refN: string
val removed_versions: Properties.T
val report: T
val reportN: string
val result: T
val resultN: string
val running: T
val runningN: string
val sendbackN: string
val serialN: string
val serial_properties: int -> Properties.T
val simp_trace_cancel: serial -> Properties.T
val simp_trace_hintN: string
val simp_trace_ignoreN: string
val simp_trace_logN: string
val simp_trace_panelN: string
val simp_trace_recurseN: string
val simp_trace_stepN: string
val skolem: T
val skolemN: string
val sorting: T
val sortingN: string
val state: T
val stateN: string
val status: T
val statusN: string
val string: T
val stringN: string
val subgoal: string -> T
val subgoalN: string
val symbolsN: string
val system: T
val systemN: string
val system_optionN: string
val taskN: string
val task_statistics: Properties.entry
val text_fold: T
val text_foldN: string
val tfree: T
val tfreeN: string
val theoryN: string
val timing: {cpu: Time.time, elapsed: Time.time, gc: Time.time} -> T
val timingN: string
val timing_properties:
{cpu: Time.time, elapsed: Time.time, gc: Time.time} -> Properties.T
val token_range: T
val token_rangeN: string
val tracing: T
val tracingN: string
val tvar: T
val tvarN: string
val type_nameN: string
val typing: T
val typingN: string
val unbreakableN: string
val url: string -> T
val urlN: string
val var: T
val varN: string
val verbatim: T
val verbatimN: string
val warning: T
val warningN: string
val widthN: string
val words: T
val wordsN: string
val writeln: T
val writelnN: string
end
structure Markup: MARKUP
val it = (): unit
infix 5 --
infix 5 :--
infix 5 :|--
infix 5 |--
infix 5 --|
infix 5 ^^
infixr 5 :::
infixr 5 @@@
infix 3 >>
infixr 0 ||
signature BASIC_SCAN =
sig
val !!: ('a * message option -> message) -> ('a -> 'b) -> 'a -> 'b
val $$: string -> string list -> string * string list
val --: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val --|: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'b * 'e
val :--: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val :::: ('a -> 'b * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val :|--: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> 'd * 'e
val >>: ('a -> 'b * 'c) * ('b -> 'd) -> 'a -> 'd * 'c
val @@@:
('a -> 'b list * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val ^^: ('a -> string * 'b) * ('b -> string * 'c) -> 'a -> string * 'c
type message = unit -> string
val |--: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'd * 'e
val ||: ('a -> 'b) * ('a -> 'b) -> 'a -> 'b
val ~$$: string -> string list -> string * string list
end
signature SCAN =
sig
val !!: ('a * message option -> message) -> ('a -> 'b) -> 'a -> 'b
val $$: string -> string list -> string * string list
val --: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val --|: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'b * 'e
val :--: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val :::: ('a -> 'b * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val :|--: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> 'd * 'e
val >>: ('a -> 'b * 'c) * ('b -> 'd) -> 'a -> 'd * 'c
val @@@:
('a -> 'b list * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val ^^: ('a -> string * 'b) * ('b -> string * 'c) -> 'a -> string * 'c
val ahead: ('a -> 'b * 'c) -> 'a -> 'b * 'a
val bulk: ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val catch: ('a -> 'b) -> 'a -> 'b
val depend: ('a -> 'b -> ('c * 'd) * 'e) -> 'a * 'b -> 'd * ('c * 'e)
val dest_lexicon: lexicon -> string list
val drain:
('a -> 'b list * 'a) ->
'b stopper ->
('c * 'b list -> 'd * ('e * 'b list)) ->
('c * 'b list) * 'a -> ('d * ('e * 'b list)) * 'a
val empty_lexicon: lexicon
val error: ('a -> 'b) -> 'a -> 'b
val extend_lexicon: string list -> lexicon -> lexicon
val fail: 'a -> 'b
val fail_with: ('a -> message) -> 'a -> 'b
val finite:
'a stopper -> ('a list -> 'b * 'a list) -> 'a list -> 'b * 'a list
val finite':
'a stopper ->
('b * 'a list -> 'c * ('d * 'a list)) ->
'b * 'a list -> 'c * ('d * 'a list)
val first: ('a -> 'b) list -> 'a -> 'b
val is_literal: lexicon -> string list -> bool
val is_stopper: 'a stopper -> 'a -> bool
type lexicon
val lift: ('a -> 'b * 'c) -> 'd * 'a -> 'b * ('d * 'c)
val literal:
lexicon ->
(string * 'a) list -> (string * 'a) list * (string * 'a) list
val make_lexicon: string list list -> lexicon
val many: ('a -> bool) -> 'a list -> 'a list * 'a list
val many1: ('a -> bool) -> 'a list -> 'a list * 'a list
val max:
('a * 'a -> bool) ->
('b -> 'a * 'b) -> ('b -> 'a * 'b) -> 'b -> 'a * 'b
val merge_lexicons: lexicon * lexicon -> lexicon
type message = unit -> string
val one: ('a -> bool) -> 'a list -> 'a * 'a list
val option: ('a -> 'b * 'a) -> 'a -> 'b option * 'a
val optional: ('a -> 'b * 'a) -> 'b -> 'a -> 'b * 'a
val pass: 'a -> ('a * 'b -> 'c * ('d * 'e)) -> 'b -> 'c * 'e
val peek: ('a -> 'b -> 'c * 'd) -> 'a * 'b -> 'c * ('a * 'd)
val permissive: ('a -> 'b) -> 'a -> 'b
val provide:
('a -> bool) -> 'b -> ('b * 'c -> 'd * ('a * 'e)) -> 'c -> 'd * 'e
val read: 'a stopper -> ('a list -> 'b * 'a list) -> 'a list -> 'b option
val recover: ('a -> 'b) -> (string -> 'a -> 'b) -> 'a -> 'b
val repeat: ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val repeat1: ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val repeats: ('a -> 'b list * 'a) -> 'a -> 'b list * 'a
val repeats1: ('a -> 'b list * 'a) -> 'a -> 'b list * 'a
val single: ('a -> 'b * 'a) -> 'a -> 'b list * 'a
val some: ('a -> 'b option) -> 'a list -> 'b * 'a list
val state: 'a * 'b -> 'a * ('a * 'b)
val stopper: ('a list -> 'a) -> ('a -> bool) -> 'a stopper
type 'a stopper
val succeed: 'a -> 'b -> 'a * 'b
val this: string list -> string list -> string list * string list
val this_string: string -> string list -> string * string list
val trace:
('a list -> 'b * 'c list) -> 'a list -> ('b * 'a list) * 'c list
val triple1: ('a * 'b) * 'c -> 'a * 'b * 'c
val triple2: 'a * ('b * 'c) -> 'a * 'b * 'c
val unless: ('a -> 'b * 'a) -> ('a -> 'c * 'd) -> 'a -> 'c * 'd
val unlift: (unit * 'a -> 'b * ('c * 'd)) -> 'a -> 'b * 'd
val |--: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'd * 'e
val ||: ('a -> 'b) * ('a -> 'b) -> 'a -> 'b
val ~$$: string -> string list -> string * string list
end
structure Scan: SCAN
structure Basic_Scan: BASIC_SCAN
type message = unit -> string
val -- = fn: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val ~$$ = fn: string -> string list -> string * string list
val |-- = fn: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'd * 'e
val !! = fn: ('a * message option -> message) -> ('a -> 'b) -> 'a -> 'b
val ::: = fn: ('a -> 'b * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val :|-- = fn: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> 'd * 'e
val $$ = fn: string -> string list -> string * string list
val @@@ = fn:
('a -> 'b list * 'c) * ('c -> 'b list * 'd) -> 'a -> 'b list * 'd
val ^^ = fn: ('a -> string * 'b) * ('b -> string * 'c) -> 'a -> string * 'c
val || = fn: ('a -> 'b) * ('a -> 'b) -> 'a -> 'b
val >> = fn: ('a -> 'b * 'c) * ('b -> 'd) -> 'a -> 'd * 'c
val --| = fn: ('a -> 'b * 'c) * ('c -> 'd * 'e) -> 'a -> 'b * 'e
val :-- = fn: ('a -> 'b * 'c) * ('b -> 'c -> 'd * 'e) -> 'a -> ('b * 'd) * 'e
val it = (): unit
signature SOURCE =
sig
val exhaust: ('a, 'b) source -> 'a list
val exhausted: ('a, 'b) source -> ('a, 'a list) source
val filter:
('a -> bool) -> ('a, 'b) source -> ('a, ('a, 'b) source) source
val get: ('a, 'b) source -> 'a list * ('a, 'b) source
val get_single: ('a, 'b) source -> ('a * ('a, 'b) source) option
val map_filter:
('a -> 'b option) -> ('a, 'c) source -> ('b, ('a, 'c) source) source
val of_list: 'a list -> ('a, 'a list) source
val of_string: string -> (string, string list) source
val source:
'a Scan.stopper ->
('a list -> 'b list * 'a list) ->
('a, 'c) source -> ('b, ('a, 'c) source) source
type ('a, 'b) source
val source':
'a ->
'b Scan.stopper ->
('a * 'b list -> 'c list * ('a * 'b list)) ->
('b, 'd) source -> ('c, 'a * ('b, 'd) source) source
val unget: 'a list * ('a, 'b) source -> ('a, 'b) source
end
structure Source: SOURCE
val it = (): unit
signature SYMBOL =
sig
val DEL: symbol
val STX: symbol
val beginning: int -> symbol list -> string
val bump_init: string -> string
val bump_string: string -> string
val close: symbol
val comment: symbol
val decode: symbol -> sym
val eof: symbol
val esc: symbol -> string
val escape: string -> string
val explode: string -> symbol list
val explode_words: string -> string list
val is_ascii: symbol -> bool
val is_ascii_blank: symbol -> bool
val is_ascii_control: symbol -> bool
val is_ascii_digit: symbol -> bool
val is_ascii_hex: symbol -> bool
val is_ascii_identifier: string -> bool
val is_ascii_letdig: symbol -> bool
val is_ascii_letter: symbol -> bool
val is_ascii_lower: symbol -> bool
val is_ascii_quasi: symbol -> bool
val is_ascii_upper: symbol -> bool
val is_blank: symbol -> bool
val is_block_ctrl: symbol -> bool
val is_char: symbol -> bool
val is_control: symbol -> bool
val is_digit: symbol -> bool
val is_eof: symbol -> bool
val is_letdig: symbol -> bool
val is_letter: symbol -> bool
val is_malformed: symbol -> bool
val is_printable: symbol -> bool
val is_quasi: symbol -> bool
val is_quasi_letter: symbol -> bool
val is_space: symbol -> bool
val is_symbolic: symbol -> bool
val is_symbolic_char: symbol -> bool
val is_utf8: symbol -> bool
val kind: symbol -> kind
datatype kind = Blank | Digit | Letter | Other | Quasi
val length: symbol list -> int
val malformed_msg: symbol -> string
val not_eof: symbol -> bool
val open_: symbol
val output: string -> string * int
val scan_ascii_id: string list -> string * string list
val scanner:
string -> (string list -> 'a * string list) -> symbol list -> 'a
val space: symbol
val spaces: int -> string
val split_words: symbol list -> string list
val stopper: symbol Scan.stopper
datatype sym =
Char of string
| Control of string
| EOF
| Malformed of string
| Sym of string
| UTF8 of string
eqtype symbol
val to_ascii_lower: symbol -> symbol
val to_ascii_upper: symbol -> symbol
val trim_blanks: string -> string
end
structure Symbol: SYMBOL
val it = (): unit
signature POSITION =
sig
eqtype T
val advance: string -> T -> T
val advance_offset: int -> T -> T
val append_reports: report_text list ref -> report list -> unit
val def_properties_of: T -> Properties.T
val default: T -> bool * T
val default_properties: T -> Properties.T -> Properties.T
val dest: T -> Thread_Position.T
val distance_of: T -> T -> int
val end_offset_of: T -> int option
val entity_properties_of: bool -> serial -> T -> Properties.T
val file: string -> T
val file_name: string -> Properties.T
val file_of: T -> string option
val file_only: string -> T
val get_id: T -> string option
val here: T -> string
val here_list: T list -> string
val id: string -> T
val id_only: string -> T
val is_reported: T -> bool
val is_reported_range: T -> bool
val line: int -> T
val line_file: int -> string -> T
val line_file_only: int -> string -> T
val line_of: T -> int option
val make: Thread_Position.T -> T
val markup: T -> Markup.T -> Markup.T
val no_range: range
val no_range_position: T -> T
val none: T
val of_properties: Properties.T -> T
val offset_of: T -> int option
val parse_id: T -> int option
val properties_of: T -> Properties.T
val properties_of_range: range -> Properties.T
val put_id: string -> T -> T
val range: T * T -> range
type range = T * T
val range_of_properties: Properties.T -> range
val range_position: range -> T
type report = T * Markup.T
val report: T -> Markup.T -> unit
type report_text = report * string
val report_text: T -> Markup.T -> string -> unit
val reported_text: T -> Markup.T -> string -> string
val reports: report list -> unit
val reports_text: report_text list -> unit
val setmp_thread_data: T -> ('a -> 'b) -> 'a -> 'b
val start: T
val store_reports:
report_text list ref -> T list -> ('a -> Markup.T list) -> 'a -> unit
val thread_data: unit -> T
end
structure Position: POSITION
val it = (): unit
signature SYMBOL_POS =
sig
val !!!: message -> (T list -> 'a) -> T list -> 'a
val $$: string -> T list -> T * T list
val $$$: string -> T list -> T list * T list
type T = string * Position.T
val cartouche_content: T list -> T list
val content: T list -> string
val explode: text * Position.T -> T list
val explode0: string -> T list
val implode: T list -> text
val implode_range: Position.range -> T list -> text * Position.range
val is_eof: T -> bool
val is_identifier: string -> bool
val quote_string_bq: string -> string
val quote_string_q: string -> string
val quote_string_qq: string -> string
val range: T list -> Position.range
val recover_cartouche: T list -> T list * T list
val recover_comment: T list -> T list * T list
val recover_string_bq: T list -> T list * T list
val recover_string_q: T list -> T list * T list
val recover_string_qq: T list -> T list * T list
val scan_cartouche: string -> T list -> T list * T list
val scan_cartouche_content: string -> T list -> T list * T list
val scan_comment: string -> T list -> T list * T list
val scan_comment_body: string -> T list -> T list * T list
val scan_float: T list -> T list * T list
val scan_ident: T list -> T list * T list
val scan_nat: T list -> T list * T list
val scan_pos: T list -> Position.T * T list
val scan_string_bq:
string -> T list -> (Position.T * (T list * Position.T)) * T list
val scan_string_q:
string -> T list -> (Position.T * (T list * Position.T)) * T list
val scan_string_qq:
string -> T list -> (Position.T * (T list * Position.T)) * T list
val source:
Position.T ->
(string, 'a) Source.source ->
(T, Position.T * (string, 'a) Source.source) Source.source
val split_lines: T list -> T list list
val stopper: T Scan.stopper
val symbol: T -> string
eqtype text
val trim_blanks: T list -> T list
val trim_lines: T list -> T list
val ~$$: string -> T list -> T * T list
val ~$$$: string -> T list -> T list * T list
end
structure Symbol_Pos: SYMBOL_POS
structure Basic_Symbol_Pos:
sig
val $$: string -> Symbol_Pos.T list -> Symbol_Pos.T * Symbol_Pos.T list
val $$$:
string -> Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val ~$$: string -> Symbol_Pos.T list -> Symbol_Pos.T * Symbol_Pos.T list
val ~$$$:
string -> Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
end
val it = (): unit
signature INPUT =
sig
val equal_content: source * source -> bool
val is_delimited: source -> bool
val pos_of: source -> Position.T
val range_of: source -> Position.range
val reset_pos: source -> source
val source: bool -> string -> Position.range -> source
type source
val source_content: source -> string
val source_explode: source -> Symbol_Pos.T list
val string: string -> source
val text_of: source -> string
end
structure Input: INPUT
val it = (): unit
signature ANTIQUOTE =
sig
type antiq =
{body: Symbol_Pos.T list,
range: Position.range, start: Position.T, stop: Position.T}
val antiq_reports: 'a antiquote list -> Position.report list
datatype 'a antiquote = Antiq of antiq | Control of control | Text of 'a
type control =
{body: Symbol_Pos.T list,
name: string * Position.T, range: Position.range}
val parse: Position.T -> Symbol_Pos.T list -> text_antiquote list
val range: text_antiquote list -> Position.range
val read: Input.source -> text_antiquote list
val scan_antiq: Symbol_Pos.T list -> antiq * Symbol_Pos.T list
val scan_antiquote:
Symbol_Pos.T list -> text_antiquote * Symbol_Pos.T list
val scan_control: Symbol_Pos.T list -> control * Symbol_Pos.T list
val split_lines: text_antiquote list -> text_antiquote list list
type text_antiquote = Symbol_Pos.T list antiquote
end
Warning: Matches are not exhaustive.
case Symbol.decode sym of Symbol.Control name => name
At (line 90 of "General/antiquote.ML")
structure Antiquote: ANTIQUOTE
val it = (): unit
signature ML_LEX =
sig
val check_content_of: token -> string
val content_of: token -> string
val end_pos_of: token -> Position.T
val flatten: token list -> string
val is_improper: token -> bool
val is_regular: token -> bool
val keywords: string list
val kind_of: token -> token_kind
val pos_of: token -> Position.T
val range_of: token -> Position.range
val read: string -> token Antiquote.antiquote list
val read_pos: Position.T -> string -> token Antiquote.antiquote list
val read_set_range:
Position.range -> string -> token Antiquote.antiquote list
val read_source: bool -> Input.source -> token Antiquote.antiquote list
val set_range: Position.range -> token -> token
val source:
(string, 'a) Source.source ->
(token,
(Symbol_Pos.T, Position.T * (string, 'a) Source.source)
Source.source) Source.source
val stopper: token Scan.stopper
eqtype token
datatype token_kind =
Char
| Comment
| EOF
| Error of string
| Ident
| Int
| Keyword
| Long_Ident
| Real
| Space
| String
| Type_Var
| Word
val tokenize: string -> token list
end
structure ML_Lex: ML_LEX
val it = (): unit
val ML_file = fn: string -> unit
val ML_file_debug = fn: string -> unit
val ML_file_no_debug = fn: string -> unit
val it = (): unit
val it = (): unit
val it = (): unit
signature INTEGER =
sig
val add: int -> int -> int
val div_mod: int -> int -> int * int
val gcd: int -> int -> int
val gcds: int list -> int
val lcm: int -> int -> int
val lcms: int list -> int
val max: int -> int -> int
val min: int -> int -> int
val mult: int -> int -> int
val pow: int -> int -> int
val prod: int list -> int
val sign: int -> order
val square: int -> int
val sum: int list -> int
end
structure Integer: INTEGER
val it = (): unit
signature STACK =
sig
type 'a T
val dest: 'a T -> 'a * 'a list
val init: 'a -> 'a T
val level: 'a T -> int
val make: 'a -> 'a list -> 'a T
val map_all: ('a -> 'a) -> 'a T -> 'a T
val map_top: ('a -> 'a) -> 'a T -> 'a T
val pop: 'a T -> 'a T
val push: 'a T -> 'a T
val top: 'a T -> 'a
end
structure Stack: STACK
val it = (): unit
signature QUEUE =
sig
type 'a T
val content: 'a T -> 'a list
val dequeue: 'a T -> 'a * 'a T
val empty: 'a T
val enqueue: 'a -> 'a T -> 'a T
val is_empty: 'a T -> bool
end
Warning: Pattern is not exhaustive.
val y :: ys = rev xs
At (line 32 of "General/queue.ML")
structure Queue: QUEUE
val it = (): unit
signature HEAP =
sig
type T
val delete_min: T -> T
type elem
val empty: T
val insert: elem -> T -> T
val is_empty: T -> bool
val merge: T * T -> T
val min: T -> elem
val min_elem: T -> elem * T
val upto: elem -> T -> elem list * T
end
functor Heap (sig type elem val ord: elem * elem -> order end): HEAP
val it = (): unit
signature SAME =
sig
exception SAME
val capture: ('a, 'b) function -> 'a -> 'b option
val commit: 'a operation -> 'a -> 'a
val function: ('a -> 'b option) -> ('a, 'b) function
type ('a, 'b) function = 'a -> 'b
val map: 'a operation -> 'a list operation
val map_option: ('a, 'b) function -> ('a option, 'b option) function
type 'a operation = ('a, 'a) function
val same: ('a, 'b) function
end
Warning: Value identifier (f) has not been referenced.
At (line 39 of "General/same.ML")
Warning: Value identifier (f) has not been referenced.
At (line 42 of "General/same.ML")
structure Same: SAME
val it = (): unit
signature ORD_LIST =
sig
eqtype 'a T
val insert: ('a * 'a -> order) -> 'a -> 'a T -> 'a T
val inter: ('a * 'b -> order) -> 'a T -> 'b T -> 'b T
val make: ('a * 'a -> order) -> 'a list -> 'a T
val member: ('a * 'b -> order) -> 'b T -> 'a -> bool
val merge: ('a * 'a -> order) -> 'a T * 'a T -> 'a T
val remove: ('a * 'b -> order) -> 'a -> 'b T -> 'b T
val subset: ('a * 'b -> order) -> 'a T * 'b T -> bool
val subtract: ('a * 'b -> order) -> 'a T -> 'b T -> 'b T
val union: ('a * 'a -> order) -> 'a T -> 'a T -> 'a T
val unions: ('a * 'a -> order) -> 'a T list -> 'a T
end
Warning: Matches are not exhaustive.
fun insrt 1 ys = x :: ys | insrt i ... = y :: ... ...
At (line 46 of "General/ord_list.ML")
Warning: Matches are not exhaustive.
fun rmove 1 (... :: ...) = ys | rmove i ... = y :: ... ...
At (line 53 of "General/ord_list.ML")
structure Ord_List: ORD_LIST
val it = (): unit
signature BALANCED_TREE =
sig
val access:
{init: 'a, left: 'a -> 'a, right: 'a -> 'a} -> int -> int -> 'a
val accesses:
{init: 'a, left: 'a -> 'a, right: 'a -> 'a} -> int -> 'a list
val dest: ('a -> 'a * 'a) -> int -> 'a -> 'a list
val make: ('a * 'a -> 'a) -> 'a list -> 'a
end
structure Balanced_Tree: BALANCED_TREE
val it = (): unit
signature LINEAR_SET =
sig
exception DUPLICATE of key
exception NEXT_UNDEFINED of key option
type 'a T
exception UNDEFINED of key
val defined: 'a T -> key -> bool
val delete_after: key option -> 'a T -> 'a T
val dest: 'a T -> (key * 'a) list
val empty: 'a T
val get_after: 'a T -> key option -> key option
val insert_after: key option -> key * 'a -> 'a T -> 'a T
val is_empty: 'a T -> bool
val iterate:
key option ->
((key option * key) * 'a -> 'b -> 'b option) -> 'a T -> 'b -> 'b
type key
val lookup: 'a T -> key -> ('a * key option) option
val update: key * 'a -> 'a T -> 'a T
end
functor Linear_Set (Key: KEY): LINEAR_SET
val it = (): unit
signature BUFFER =
sig
type T
val add: string -> T -> T
val content: T -> string
val empty: T
val markup: Markup.T -> (T -> T) -> T -> T
val output: T -> BinIO.outstream -> unit
end
structure Buffer: BUFFER
val it = (): unit
signature PRETTY =
sig
type T
val add_mode: string -> (string -> int -> string) -> unit
val big_list: string -> T list -> T
val blk: int * T list -> T
val block: T list -> T
val block_enclose: T * T -> T list -> T
val breaks: T list -> T list
val brk: int -> T
val brk_indent: int -> int -> T
val cartouche: T -> T
val chunks: T list -> T
val chunks2: T list -> T
val commas: T list -> T list
val default_indent: string -> int -> string
val enclose: string -> string -> T list -> T
val enum: string -> string -> string -> T list -> T
val fbreaks: T list -> T list
val fbrk: T
val from_ML: ML_Pretty.pretty -> T
val from_polyml: PolyML.pretty -> T
val indent: int -> T -> T
val item: T list -> T
val keyword1: string -> T
val keyword2: string -> T
val list: string -> string -> T list -> T
val make_block:
{consistent: bool, indent: int, markup: string * string} ->
T list -> T
val margin_default: int ref
val mark: Markup.T -> T -> T
val mark_str: Markup.T * string -> T
val marks_str: Markup.T list * string -> T
val markup: Markup.T -> T list -> T
val markup_block:
{consistent: bool, indent: int, markup: Markup.T} -> T list -> T
val markup_chunks: Markup.T -> T list -> T
val output: int option -> T -> string
val output_buffer: int option -> T -> Buffer.T
val para: string -> T
val paragraph: T list -> T
val position: Position.T -> T
val quote: T -> T
val separate: string -> T list -> T list
val str: string -> T
val str_list: string -> string -> string list -> T
val string_of: T -> string
val string_of_margin: int -> T -> string
val strs: string list -> T
val symbolicN: string
val symbolic_output: T -> string
val symbolic_string_of: T -> string
val text: string -> T list
val text_fold: T list -> T
val to_ML: int -> T -> ML_Pretty.pretty
val to_polyml: T -> PolyML.pretty
val unbreakable: T -> T
val unformatted_string_of: T -> string
val writeln: T -> unit
val writeln_chunks: T list -> unit
val writeln_chunks2: T list -> unit
end
Warning: Matches are not exhaustive.
case rest of
Break (true, ...) :: rest' => body_length (... ... :: rest') len' |
[] => len'
At (line 135 of "General/pretty.ML")
structure Pretty: PRETTY
structure ML_Pretty:
sig
val block: pretty list -> pretty
val brk: int -> pretty
val default_margin: int
val enum:
string ->
string -> string -> ('a * int -> pretty) -> 'a list * int -> pretty
val format: int -> pretty -> string
val format_polyml: int -> PolyML.pretty -> string
val from_polyml: PolyML.pretty -> pretty
val make_string_fn: string
val pair:
('a * int -> pretty) ->
('b * int -> pretty) -> ('a * 'b) * int -> pretty
datatype pretty =
Block of (string * string) * bool * int * pretty list
| Break of bool * int * int
| String of string * int
val str: string -> pretty
val string_of_polyml: PolyML.pretty -> string
val to_polyml: pretty -> PolyML.pretty
end
val it = (): unit
signature RAT =
sig
val abs: rat -> rat
val add: rat -> rat -> rat
val ceil: rat -> int
val dest: rat -> int * int
val floor: rat -> int
val inv: rat -> rat
val le: rat -> rat -> bool
val lt: rat -> rat -> bool
val make: int * int -> rat
val mult: rat -> rat -> rat
val neg: rat -> rat
val of_int: int -> rat
val ord: rat * rat -> order
eqtype rat
val sign: rat -> order
val signed_string_of_rat: rat -> string
val string_of_rat: rat -> string
end
structure Rat: RAT
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
val it = (): unit
signature XML_DATA_OPS =
sig
type 'a A
type 'a T
type 'a V
val bool: bool T
val bool_atom: bool A
val int: int T
val int_atom: int A
val list: 'a T -> 'a list T
val option: 'a T -> 'a option T
val pair: 'a T -> 'b T -> ('a * 'b) T
val properties: Properties.T T
val string: string T
val triple: 'a T -> 'b T -> 'c T -> ('a * 'b * 'c) T
val unit: unit T
val unit_atom: unit A
val variant: 'a V list -> 'a T
end
signature XML =
sig
structure Decode:
sig
type 'a A
type 'a T
type 'a V
val bool: bool T
val bool_atom: bool A
val int: int T
val int_atom: int A
val list: 'a T -> 'a list T
val option: 'a T -> 'a option T
val pair: 'a T -> 'b T -> ('a * 'b) T
val properties: Properties.T T
val string: string T
val tree: tree T
val triple: 'a T -> 'b T -> 'c T -> ('a * 'b * 'c) T
val unit: unit T
val unit_atom: unit A
val variant: 'a V list -> 'a T
end
structure Encode:
sig
type 'a A
type 'a T
type 'a V
val bool: bool T
val bool_atom: bool A
val int: int T
val int_atom: int A
val list: 'a T -> 'a list T
val option: 'a T -> 'a option T
val pair: 'a T -> 'b T -> ('a * 'b) T
val properties: Properties.T T
val string: string T
val tree: tree T
val triple: 'a T -> 'b T -> 'c T -> ('a * 'b * 'c) T
val unit: unit T
val unit_atom: unit A
val variant: 'a V list -> 'a T
end
exception XML_ATOM of string
exception XML_BODY of body
val add_content: tree -> Buffer.T -> Buffer.T
type attributes = (string * string) list
type body = tree list
val content_of: body -> string
val element: string -> attributes -> string list -> string
val header: string
val output: tree -> BinIO.outstream -> unit
val output_markup: Markup.T -> string * string
val parse: string -> tree
val parse_comments: string list -> unit * string list
val parse_document: string list -> tree * string list
val parse_element: string list -> tree * string list
val parse_string: string -> string option
val pretty: int -> tree -> Pretty.T
val string_of: tree -> string
val text: string -> string
datatype tree =
Elem of (string * attributes) * tree list
| Text of string
val trim_blanks: body -> body
val unwrap_elem:
tree -> (((string * attributes) * tree list) * tree list) option
val wrap_elem: ((string * attributes) * tree list) * tree list -> tree
end
structure XML: XML
val it = (): unit
signature PATH =
sig
eqtype T
val append: T -> T -> T
val appends: T list -> T
val base: T -> T
val base_name: T -> string
val basic: string -> T
val current: T
val decode: T XML.Decode.T
val dir: T -> T
val expand: T -> T
val explode: string -> T
val ext: string -> T -> T
val implode: T -> string
val is_absolute: T -> bool
val is_basic: T -> bool
val is_current: T -> bool
val make: string list -> T
val named_root: string -> T
val parent: T
val position: T -> Position.T
val pretty: T -> Pretty.T
val print: T -> string
val root: T
val smart_implode: T -> string
val split: string -> T list
val split_ext: T -> T * string
val starts_basic: T -> bool
val variable: string -> T
end
structure Path: PATH
val it = (): unit
signature URL =
sig
datatype T =
File of Path.T
| Ftp of string * Path.T
| Http of string * Path.T
val append: T -> T -> T
val explode: string -> T
val implode: T -> string
val pretty: T -> Pretty.T
val print: T -> string
end
structure Url: URL
val it = (): unit
signature BASH_SYNTAX =
sig val string: string -> string val strings: string list -> string end
structure Bash_Syntax: BASH_SYNTAX
val it = (): unit
signature FILE =
sig
val append: Path.T -> string -> unit
val append_list: Path.T -> string list -> unit
val bash_path: Path.T -> string
val check_dir: Path.T -> Path.T
val check_file: Path.T -> Path.T
val eq: Path.T * Path.T -> bool
val exists: Path.T -> bool
val fold_dir: (string -> 'a -> 'a) -> Path.T -> 'a -> 'a
val fold_lines: (string -> 'a -> 'a) -> Path.T -> 'a -> 'a
val fold_pages: (string -> 'a -> 'a) -> Path.T -> 'a -> 'a
val full_path: Path.T -> Path.T -> Path.T
val is_dir: Path.T -> bool
val open_append: (BinIO.outstream -> 'a) -> Path.T -> 'a
val open_dir: (OS.FileSys.dirstream -> 'a) -> Path.T -> 'a
val open_input: (BinIO.instream -> 'a) -> Path.T -> 'a
val open_output: (BinIO.outstream -> 'a) -> Path.T -> 'a
val output: BinIO.outstream -> string -> unit
val platform_path: Path.T -> string
val read: Path.T -> string
val read_dir: Path.T -> string list
val read_lines: Path.T -> string list
val read_pages: Path.T -> string list
val rm: Path.T -> unit
val standard_path: Path.T -> string
val tmp_path: Path.T -> Path.T
val write: Path.T -> string -> unit
val write_buffer: Path.T -> Buffer.T -> unit
val write_list: Path.T -> string list -> unit
end
Warning: Matches are not exhaustive.
case String.fields (fn c => ... = ...) input of
[rest] => read (... ... buf) x |
line :: more => read_lines more (... ... x)
At (line 132 of "General/file.ML")
Warning: Matches are not exhaustive.
fun
read buf x
=
(
case Byte.bytesToString (... ...) of
"" => (case ... of ...) |
... => ...) and
read_lines [...] ... = ... ... x | read_lines ... = ... ...
At (line 134 of "General/file.ML")
structure File: FILE
val it = (): unit
signature LONG_NAME =
sig
val append: string -> string -> string
val base_name: string -> string
val dest_hidden: string -> string option
val dest_local: string -> string option
val explode: string -> string list
val hidden: string -> string
val implode: string list -> string
val is_hidden: string -> bool
val is_qualified: string -> bool
val localN: string
val map_base_name: (string -> string) -> string -> string
val qualification: string -> int
val qualifier: string -> string
val qualify: string -> string -> string
val separator: string
end
structure Long_Name: LONG_NAME
val it = (): unit
eqtype bstring
signature BINDING =
sig
val bad: binding -> string
eqtype binding
val check: binding -> unit
val concealed: binding -> binding
val conglomerate: binding list -> binding
val default_pos: binding -> binding
val empty: binding
val empty_atts: binding * 'a list
val eq_name: binding * binding -> bool
val is_empty: binding -> bool
val is_empty_atts: binding * 'a list -> bool
val make: bstring * Position.T -> binding
val map_name: (bstring -> bstring) -> binding -> binding
val map_prefix:
((string * bool) list -> (string * bool) list) -> binding -> binding
val name: bstring -> binding
val name_of: binding -> bstring
val name_spec:
scope list ->
(string * bool) list ->
binding ->
{concealed: bool,
restriction: bool option, spec: (string * bool) list}
val new_scope: unit -> scope
val path_of: binding -> (string * bool) list
val pos_of: binding -> Position.T
val prefix: bool -> string -> binding -> binding
val prefix_name: string -> binding -> binding
val prefix_of: binding -> (string * bool) list
val pretty: binding -> Pretty.T
val print: binding -> string
val qualified_name: string -> binding
val qualify: bool -> string -> binding -> binding
val qualify_name: bool -> binding -> string -> binding
val reset_pos: binding -> binding
val restricted: (bool * scope) option -> binding -> binding
eqtype scope
val set_pos: Position.T -> binding -> binding
val suffix_name: string -> binding -> binding
end
structure Binding: BINDING
eqtype binding
val it = (): unit
signature SOCKET_IO =
sig
val make_streams:
Socket.active INetSock.stream_sock -> BinIO.instream * BinIO.outstream
val open_streams: string -> BinIO.instream * BinIO.outstream
end
structure Socket_IO: SOCKET_IO
val it = (): unit
signature SEQ =
sig
val APPEND: ('a -> 'b seq) * ('a -> 'b seq) -> 'a -> 'b seq
val DETERM: ('a -> 'b seq) -> 'a -> 'b seq
val EVERY: ('a -> 'a seq) list -> 'a -> 'a seq
val FIRST: ('a -> 'b seq) list -> 'a -> 'b seq
val INTERVAL: (int -> 'a -> 'a seq) -> int -> int -> 'a -> 'a seq
val ORELSE: ('a -> 'b seq) * ('a -> 'b seq) -> 'a -> 'b seq
val REPEAT: ('a -> 'a seq) -> 'a -> 'a seq
val REPEAT1: ('a -> 'a seq) -> 'a -> 'a seq
val THEN: ('a -> 'b seq) * ('b -> 'c seq) -> 'a -> 'c seq
val TRY: ('a -> 'a seq) -> 'a -> 'a seq
val append: 'a seq -> 'a seq -> 'a seq
val chop: int -> 'a seq -> 'a list * 'a seq
val cons: 'a -> 'a seq -> 'a seq
val empty: 'a seq
val fail: 'a -> 'b seq
val filter: ('a -> bool) -> 'a seq -> 'a seq
val filter_results: 'a result seq -> 'a seq
val first_result: string -> 'a result seq -> 'a * 'a seq
val flat: 'a seq seq -> 'a seq
val hd: 'a seq -> 'a
val interleave: 'a seq * 'a seq -> 'a seq
val it_right: ('a * 'b seq -> 'b seq) -> 'a seq * 'b seq -> 'b seq
val lift: ('a -> 'b -> 'c) -> 'a seq -> 'b -> 'c seq
val lifts: ('a -> 'b -> 'c seq) -> 'a seq -> 'b -> 'c seq
val list_of: 'a seq -> 'a list
val make: (unit -> ('a * 'a seq) option) -> 'a seq
val make_results: 'a seq -> 'a result seq
val map: ('a -> 'b) -> 'a seq -> 'b seq
val map_filter: ('a -> 'b option) -> 'a seq -> 'b seq
val map_result: ('a -> 'b) -> 'a result seq -> 'b result seq
val mapp: ('a -> 'b) -> 'a seq -> 'b seq -> 'b seq
val maps: ('a -> 'b seq) -> 'a seq -> 'b seq
val maps_result: ('a -> 'b seq) -> 'a result seq -> 'b result seq
val maps_results: ('a -> 'b result seq) -> 'a result seq -> 'b result seq
val of_list: 'a list -> 'a seq
val print: (int -> 'a -> unit) -> int -> 'a seq -> unit
val pull: 'a seq -> ('a * 'a seq) option
datatype 'a result = Error of unit -> string | Result of 'a
type 'a seq
val single: 'a -> 'a seq
val singleton: ('a list -> 'b list seq) -> 'a -> 'b seq
val succeed: 'a -> 'a seq
val take: int -> 'a seq -> 'a seq
val the_result: string -> 'a result seq -> 'a
val tl: 'a seq -> 'a seq
val try: ('a -> 'b) -> 'a -> 'b seq
end
structure Seq: SEQ
val it = (): unit
signature BASIC_TIMING =
sig
val cond_timeit: bool -> string -> (unit -> 'a) -> 'a
val timeap: ('a -> 'b) -> 'a -> 'b
val timeap_msg: string -> ('a -> 'b) -> 'a -> 'b
val timeit: (unit -> 'a) -> 'a
end
signature TIMING =
sig
val cond_timeit: bool -> string -> (unit -> 'a) -> 'a
val is_relevant: timing -> bool
val is_relevant_time: Time.time -> bool
val message: timing -> string
val protocol: Properties.T -> ('a -> 'b) -> 'a -> 'b
val protocol_message: Properties.T -> timing -> unit
val result: start -> timing
val start: unit -> start
type start
val timeap: ('a -> 'b) -> 'a -> 'b
val timeap_msg: string -> ('a -> 'b) -> 'a -> 'b
val timeit: (unit -> 'a) -> 'a
val timing: ('a -> 'b) -> 'a -> timing * 'b
type timing = {cpu: Time.time, elapsed: Time.time, gc: Time.time}
end
structure Timing: TIMING
structure Basic_Timing: BASIC_TIMING
val timeit = fn: (unit -> 'a) -> 'a
val timeap = fn: ('a -> 'b) -> 'a -> 'b
val timeap_msg = fn: string -> ('a -> 'b) -> 'a -> 'b
val cond_timeit = fn: bool -> string -> (unit -> 'a) -> 'a
val it = (): unit
signature SHA1 =
sig
val digest: string -> digest
eqtype digest
val fake: string -> digest
val rep: digest -> string
val test_samples: unit -> unit
end
structure SHA1: SHA1
val it = (): unit
signature YXML =
sig
val X: string
val Y: string
val content_of: string -> string
val detect: string -> bool
val embed_controls: string -> string
val output_markup: Markup.T -> string * string
val output_markup_elem: Markup.T -> (string * string) * string
val parse: string -> XML.tree
val parse_body: string -> XML.body
val string_of: XML.tree -> string
val string_of_body: XML.body -> string
end
Warning: Pattern is not exhaustive.
val [bg1, bg2, en] = space_explode Z (string_of (XML.wrap_elem (...)))
At (line 89 of "PIDE/yxml.ML")
Warning: Matches are not exhaustive.
fun add x (... :: ...) = (elem, ...) :: pending
At (line 117 of "PIDE/yxml.ML")
Warning: Matches are not exhaustive.
fun
pop ((...) :: _) = err_unbalanced "" | pop (... :: ...) = ... ... pending
At (line 122 of "PIDE/yxml.ML")
Warning: Matches are not exhaustive.
case fold parse_chunk (split_string source) [(("", ...), [...])] of
[(("", ...), result)] => rev result |
((...), ...) :: _ => err_unbalanced name
At (line 142 of "PIDE/yxml.ML")
structure YXML: YXML
val it = (): unit
signature DOCUMENT_ID =
sig
eqtype command
eqtype exec
eqtype execution
eqtype generic
val make: unit -> generic
val none: generic
val parse: string -> generic
val print: generic -> string
eqtype version
end
structure Document_ID: DOCUMENT_ID
val it = (): unit
signature CHANGE_TABLE =
sig
exception DUP of key
exception SAME
type 'a T
structure Table: TABLE
val change_base: bool -> 'a T -> 'a T
val change_ignore: 'a T -> 'a T
val defined: 'a T -> key -> bool
val delete_safe: key -> 'a T -> 'a T
val dest: 'a T -> (key * 'a) list
val empty: 'a T
val fold: (key * 'a -> 'b -> 'b) -> 'a T -> 'b -> 'b
val is_empty: 'a T -> bool
val join: (key -> 'a * 'a -> 'a) -> 'a T * 'a T -> 'a T
type key
val lookup: 'a T -> key -> 'a option
val lookup_key: 'a T -> key -> (key * 'a) option
val map_default: key * 'a -> ('a -> 'a) -> 'a T -> 'a T
val map_entry: key -> ('a -> 'a) -> 'a T -> 'a T
val merge: ('a * 'a -> bool) -> 'a T * 'a T -> 'a T
val table_of: 'a T -> 'a Table.table
val update: key * 'a -> 'a T -> 'a T
val update_new: key * 'a -> 'a T -> 'a T
end
functor Change_Table (Key: KEY): CHANGE_TABLE
structure Change_Table: CHANGE_TABLE
val it = (): unit
signature GRAPH =
sig
exception CYCLES of key list list
exception DEP of key * key
exception DUP of key
structure Keys:
sig
type T
val dest: T -> key list
val fold: (key -> 'a -> 'a) -> T -> 'a -> 'a
val fold_rev: (key -> 'a -> 'a) -> T -> 'a -> 'a
val is_empty: T -> bool
end
exception SAME
type 'a T
exception UNDEF of key
val add_deps_acyclic: key * key list -> 'a T -> 'a T
val add_edge: key * key -> 'a T -> 'a T
val add_edge_acyclic: key * key -> 'a T -> 'a T
val add_edge_trans_acyclic: key * key -> 'a T -> 'a T
val all_preds: 'a T -> key list -> key list
val all_succs: 'a T -> key list -> key list
val decode: key XML.Decode.T -> 'a XML.Decode.T -> 'a T XML.Decode.T
val default_node: key * 'a -> 'a T -> 'a T
val del_edge: key * key -> 'a T -> 'a T
val del_node: key -> 'a T -> 'a T
val dest: 'a T -> ((key * 'a) * key list) list
val empty: 'a T
val encode: key XML.Encode.T -> 'a XML.Encode.T -> 'a T XML.Encode.T
val fold:
(key * ('a * (Keys.T * Keys.T)) -> 'b -> 'b) -> 'a T -> 'b -> 'b
val get_entry: 'a T -> key -> key * ('a * (Keys.T * Keys.T))
val get_first:
(key * ('a * (Keys.T * Keys.T)) -> 'b option) -> 'a T -> 'b option
val get_node: 'a T -> key -> 'a
val imm_preds: 'a T -> key -> Keys.T
val imm_succs: 'a T -> key -> Keys.T
val immediate_preds: 'a T -> key -> key list
val immediate_succs: 'a T -> key -> key list
val irreducible_paths: 'a T -> key * key -> key list list
val is_edge: 'a T -> key * key -> bool
val is_empty: 'a T -> bool
val is_maximal: 'a T -> key -> bool
val is_minimal: 'a T -> key -> bool
val join: (key -> 'a * 'a -> 'a) -> 'a T * 'a T -> 'a T
type key
val keys: 'a T -> key list
val make: ((key * 'a) * key list) list -> 'a T
val map: (key -> 'a -> 'b) -> 'a T -> 'b T
val map_node: key -> ('a -> 'a) -> 'a T -> 'a T
val map_strong_conn: ((key * 'a) list -> 'b list) -> 'a T -> 'b T
val maximals: 'a T -> key list
val merge: ('a * 'a -> bool) -> 'a T * 'a T -> 'a T
val merge_acyclic: ('a * 'a -> bool) -> 'a T * 'a T -> 'a T
val merge_trans_acyclic: ('a * 'a -> bool) -> 'a T * 'a T -> 'a T
val minimals: 'a T -> key list
val new_node: key * 'a -> 'a T -> 'a T
val restrict: (key -> bool) -> 'a T -> 'a T
val schedule: ((key * 'a) list -> key * 'b -> 'a) -> 'b T -> 'a list
val strong_conn: 'a T -> key list list
val topological_order: 'a T -> key list
end
functor Graph (Key: KEY): GRAPH
structure Graph: GRAPH
structure String_Graph: GRAPH
structure Int_Graph: GRAPH
val it = (): unit
val it = (): unit
signature NAME =
sig
val aT: string
val bound: int -> string
val clean: string -> string
val clean_index: string * int -> string * int
val context: context
type context
val declare: string -> context -> context
val dest_internal: string -> string
val dest_skolem: string -> string
val desymbolize: bool option -> string -> string
val enforce_case: bool -> string -> string
val internal: string -> string
val invent: context -> string -> int -> string list
val invent_list: string list -> string -> int -> string list
val invent_names: context -> string -> 'a list -> (string * 'a) list
val is_bound: string -> bool
val is_declared: context -> string -> bool
val is_internal: string -> bool
val is_skolem: string -> bool
val make_context: string list -> context
val reject_internal: string * Position.T list -> unit
val reject_skolem: string * Position.T list -> unit
val skolem: string -> string
val uu: string
val uu_: string
val variant: string -> context -> string * context
val variant_list: string list -> string list -> string list
end
Warning: Pattern is not exhaustive.
val xs as (x :: _) = Symbol.explode s
At (line 165 of "name.ML")
structure Name: NAME
val it = (): unit
infix 9 $
infixr 5 -->
infixr 0 --->
infix 0 aconv
signature BASIC_TERM =
sig
val --->: typ list * typ -> typ
val -->: typ * typ -> typ
exception TERM of string * term list
exception TYPE of string * typ list * term list
val absdummy: typ -> term -> term
val absfree: string * typ -> term -> term
val abstract_over: term * term -> term
val aconv: term * term -> bool
val add_loose_bnos: term * int * int list -> int list
type arity = string * sort list * sort
val betapply: term * term -> term
val betapplys: term * term list -> term
val binder_types: typ -> typ list
val body_type: typ -> typ
val burrow_types: (typ list -> typ list) -> term list -> term list
eqtype class
val dest_Const: term -> string * typ
val dest_Free: term -> string * typ
val dest_TFree: typ -> string * sort
val dest_TVar: typ -> indexname * sort
val dest_Type: typ -> string * typ list
val dest_Var: term -> indexname * typ
val dest_comb: term -> term * term
val dest_funT: typ -> typ * typ
val domain_type: typ -> typ
val dummyS: sort
val dummyT: typ
val exists_Const: (string * typ -> bool) -> term -> bool
val exists_subterm: (term -> bool) -> term -> bool
val exists_subtype: (typ -> bool) -> typ -> bool
val exists_type: (typ -> bool) -> term -> bool
val fastype_of: term -> typ
val fastype_of1: typ list * term -> typ
val fold_aterms: (term -> 'a -> 'a) -> term -> 'a -> 'a
val fold_atyps: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_atyps_sorts: (typ * sort -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_subtypes: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_term_types: (term -> typ -> 'a -> 'a) -> term -> 'a -> 'a
val fold_types: (typ -> 'a -> 'a) -> term -> 'a -> 'a
val head_of: term -> term
val incr_boundvars: int -> term -> term
val incr_bv: int * int * term -> term
type indexname = string * int
val is_Bound: term -> bool
val is_Const: term -> bool
val is_Free: term -> bool
val is_TVar: typ -> bool
val is_Var: term -> bool
val is_first_order: string list -> term -> bool
val lambda: term -> term -> term
val list_comb: term * term list -> term
val loose_bnos: term -> int list
val loose_bvar: term * int -> bool
val loose_bvar1: term * int -> bool
val map_aterms: (term -> term) -> term -> term
val map_atyps: (typ -> typ) -> typ -> typ
val map_type_tfree: (string * sort -> typ) -> typ -> typ
val map_type_tvar: (indexname * sort -> typ) -> typ -> typ
val map_types: (typ -> typ) -> term -> term
val maxidx_of_term: term -> int
val maxidx_of_typ: typ -> int
val maxidx_of_typs: typ list -> int
val no_dummyT: typ -> typ
val propT: typ
val range_type: typ -> typ
val size_of_term: term -> int
val size_of_typ: typ -> int
type sort = class list
val strip_abs: term -> (string * typ) list * term
val strip_abs_body: term -> term
val strip_abs_vars: term -> (string * typ) list
val strip_all_body: term -> term
val strip_all_vars: term -> (string * typ) list
val strip_comb: term -> term * term list
val strip_qnt_body: string -> term -> term
val strip_qnt_vars: string -> term -> (string * typ) list
val strip_type: typ -> typ list * typ
val subst_TVars: (indexname * typ) list -> term -> term
val subst_Vars: (indexname * term) list -> term -> term
val subst_atomic: (term * term) list -> term -> term
val subst_atomic_types: (typ * typ) list -> term -> term
val subst_bound: term * term -> term
val subst_bounds: term list * term -> term
val subst_free: (term * term) list -> term -> term
val subst_vars:
(indexname * typ) list * (indexname * term) list -> term -> term
datatype term =
$ of term * term
| Abs of string * typ * term
| Bound of int
| Const of string * typ
| Free of string * typ
| Var of indexname * typ
datatype typ =
TFree of string * sort
| TVar of indexname * sort
| Type of string * typ list
val typ_subst_TVars: (indexname * typ) list -> typ -> typ
val typ_subst_atomic: (typ * typ) list -> typ -> typ
val type_of: term -> typ
val type_of1: typ list * term -> typ
end
signature TERM =
sig
val --->: typ list * typ -> typ
val -->: typ * typ -> typ
exception TERM of string * term list
exception TYPE of string * typ list * term list
val aT: sort -> typ
val a_itselfT: typ
val abs: string * typ -> term -> term
val absdummy: typ -> term -> term
val absfree: string * typ -> term -> term
val abstract_over: term * term -> term
val aconv: term * term -> bool
val aconv_untyped: term * term -> bool
val add_const_names: term -> string list -> string list
val add_consts: term -> (string * typ) list -> (string * typ) list
val add_free_names: term -> string list -> string list
val add_frees: term -> (string * typ) list -> (string * typ) list
val add_loose_bnos: term * int * int list -> int list
val add_tfree_names: term -> string list -> string list
val add_tfree_namesT: typ -> string list -> string list
val add_tfrees: term -> (string * sort) list -> (string * sort) list
val add_tfreesT: typ -> (string * sort) list -> (string * sort) list
val add_tvar_names: term -> indexname list -> indexname list
val add_tvar_namesT: typ -> indexname list -> indexname list
val add_tvars: term -> (indexname * sort) list -> (indexname * sort) list
val add_tvarsT: typ -> (indexname * sort) list -> (indexname * sort) list
val add_var_names: term -> indexname list -> indexname list
val add_vars: term -> (indexname * typ) list -> (indexname * typ) list
val argument_type_of: term -> int -> typ
type arity = string * sort list * sort
val betapply: term * term -> term
val betapplys: term * term list -> term
val binder_types: typ -> typ list
val body_type: typ -> typ
val burrow_types: (typ list -> typ list) -> term list -> term list
eqtype class
val close_schematic_term: term -> term
val could_beta_contract: term -> bool
val could_beta_eta_contract: term -> bool
val could_eta_contract: term -> bool
val could_unify: term * term -> bool
val declare_term_frees: term -> Name.context -> Name.context
val declare_term_names: term -> Name.context -> Name.context
val declare_typ_names: typ -> Name.context -> Name.context
val dependent_lambda_name: string * term -> term -> term
val dest_Const: term -> string * typ
val dest_Free: term -> string * typ
val dest_TFree: typ -> string * sort
val dest_TVar: typ -> indexname * sort
val dest_Type: typ -> string * typ list
val dest_Var: term -> indexname * typ
val dest_abs: string * typ * term -> string * term
val dest_comb: term -> term * term
val dest_funT: typ -> typ * typ
val domain_type: typ -> typ
val dummy: term
val dummyS: sort
val dummyT: typ
val dummy_pattern: typ -> term
val dummy_prop: term
val eq_ix: indexname * indexname -> bool
val eq_tvar: (indexname * sort) * (indexname * sort) -> bool
val eq_var: (indexname * typ) * (indexname * typ) -> bool
val exists_Const: (string * typ -> bool) -> term -> bool
val exists_subterm: (term -> bool) -> term -> bool
val exists_subtype: (typ -> bool) -> typ -> bool
val exists_type: (typ -> bool) -> term -> bool
val fastype_of: term -> typ
val fastype_of1: typ list * term -> typ
val fold_aterms: (term -> 'a -> 'a) -> term -> 'a -> 'a
val fold_atyps: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_atyps_sorts: (typ * sort -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_subtypes: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val fold_term_types: (term -> typ -> 'a -> 'a) -> term -> 'a -> 'a
val fold_types: (typ -> 'a -> 'a) -> term -> 'a -> 'a
val free_dummy_patterns: term -> Name.context -> term * Name.context
val head_of: term -> term
val hidden_polymorphism: term -> (indexname * sort) list
val incr_boundvars: int -> term -> term
val incr_bv: int * int * term -> term
type indexname = string * int
val is_Bound: term -> bool
val is_Const: term -> bool
val is_Free: term -> bool
val is_TVar: typ -> bool
val is_Var: term -> bool
val is_dependent: term -> bool
val is_dummy_pattern: term -> bool
val is_first_order: string list -> term -> bool
val is_open: term -> bool
val itselfT: typ -> typ
val lambda: term -> term -> term
val lambda_name: string * term -> term -> term
val list_comb: term * term list -> term
val loose_bnos: term -> int list
val loose_bvar: term * int -> bool
val loose_bvar1: term * int -> bool
val map_abs_vars: (string -> string) -> term -> term
val map_aterms: (term -> term) -> term -> term
val map_atyps: (typ -> typ) -> typ -> typ
val map_type_tfree: (string * sort -> typ) -> typ -> typ
val map_type_tvar: (indexname * sort -> typ) -> typ -> typ
val map_types: (typ -> typ) -> term -> term
val match_bvars:
term * term -> (string * string) list -> (string * string) list
val maxidx_of_term: term -> int
val maxidx_of_typ: typ -> int
val maxidx_of_typs: typ list -> int
val maxidx_term: term -> int -> int
val maxidx_typ: typ -> int -> int
val maxidx_typs: typ list -> int -> int
val no_dummyT: typ -> typ
val no_dummy_patterns: term -> term
val propT: typ
val range_type: typ -> typ
val rename_abs: term -> term -> term -> term option
val rename_wrt_term: term -> (string * 'a) list -> (string * 'a) list
val replace_dummy_patterns: term -> int -> term * int
val show_dummy_patterns: term -> term
val size_of_term: term -> int
val size_of_typ: typ -> int
type sort = class list
val string_of_vname: indexname -> string
val string_of_vname': indexname -> string
val strip_abs: term -> (string * typ) list * term
val strip_abs_body: term -> term
val strip_abs_eta: int -> term -> (string * typ) list * term
val strip_abs_vars: term -> (string * typ) list
val strip_all_body: term -> term
val strip_all_vars: term -> (string * typ) list
val strip_comb: term -> term * term list
val strip_qnt_body: string -> term -> term
val strip_qnt_vars: string -> term -> (string * typ) list
val strip_type: typ -> typ list * typ
val subst_TVars: (indexname * typ) list -> term -> term
val subst_Vars: (indexname * term) list -> term -> term
val subst_atomic: (term * term) list -> term -> term
val subst_atomic_types: (typ * typ) list -> term -> term
val subst_bound: term * term -> term
val subst_bounds: term list * term -> term
val subst_free: (term * term) list -> term -> term
val subst_vars:
(indexname * typ) list * (indexname * term) list -> term -> term
datatype term =
$ of term * term
| Abs of string * typ * term
| Bound of int
| Const of string * typ
| Free of string * typ
| Var of indexname * typ
val term_name: term -> string
datatype typ =
TFree of string * sort
| TVar of indexname * sort
| Type of string * typ list
val typ_subst_TVars: (indexname * typ) list -> typ -> typ
val typ_subst_atomic: (typ * typ) list -> typ -> typ
val type_of: term -> typ
val type_of1: typ list * term -> typ
val variant_frees: term -> (string * 'a) list -> (string * 'a) list
end
Warning: Matches are not exhaustive.
fun domain_type (Type (...)) = T
At (line 290 of "term.ML")
Warning: Matches are not exhaustive.
fun range_type (Type (...)) = U
At (line 292 of "term.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 316 of "term.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 313 of "term.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 312 of "term.ML")
Warning: Value identifier (u) has not been referenced.
At (line 372 of "term.ML")
Warning: Value identifier (t) has not been referenced.
At (line 382 of "term.ML")
Warning: Value identifier (t) has not been referenced.
At (line 398 of "term.ML")
Warning: Matches are not exhaustive.
fn T as TFree (_, ...) => f (T, S) | T as TVar (...) => f (T, ...)
At (line 443 of "term.ML")
Warning: Value identifier (f) has not been referenced.
At (line 452 of "term.ML")
Warning: Matches are not exhaustive.
fun
replace_types (Const (...)) (... :: ...) = (Const (...), Ts) |
replace_types (... ...) ... = (... ..., ...) |
replace_types ... = (...) |
replace_types ... = ... |
...
At (line 458 of "term.ML")
Warning: Pattern is not exhaustive.
val (ts', []) = fold_map replace_types ts Ts'
At (line 475 of "term.ML")
Warning: Value identifier (t) has not been referenced.
At (line 591 of "term.ML")
Warning: Value identifier (lev) has not been referenced.
At (line 602 of "term.ML")
Warning: Value identifier (inc) has not been referenced.
At (line 602 of "term.ML")
Warning: Value identifier (f) has not been referenced.
At (line 620 of "term.ML")
Warning: Value identifier (t) has not been referenced.
At (line 667 of "term.ML")
Warning: Value identifier (a) has not been referenced.
At (line 846 of "term.ML")
Warning: Value identifier (ts) has not been referenced.
At (line 855 of "term.ML")
Warning: Value identifier (ts) has not been referenced.
At (line 855 of "term.ML")
Warning: Pattern is not exhaustive.
val [x] = Name.invent used Name.uu 1
At (line 967 of "term.ML")
structure Term: TERM
structure Basic_Term: BASIC_TERM
type sort = class list
type arity = string * sort list * sort
type indexname = string * int
eqtype class
datatype typ =
TFree of string * sort
| TVar of indexname * sort
| Type of string * typ list
datatype term =
$ of term * term
| Abs of string * typ * term
| Bound of int
| Const of string * typ
| Free of string * typ
| Var of indexname * typ
val loose_bvar1 = fn: term * int -> bool
val burrow_types = fn: (typ list -> typ list) -> term list -> term list
val exists_subterm = fn: (term -> bool) -> term -> bool
val strip_type = fn: typ -> typ list * typ
val maxidx_of_typ = fn: typ -> int
val typ_subst_TVars = fn: (indexname * typ) list -> typ -> typ
val subst_bounds = fn: term list * term -> term
val strip_abs_vars = fn: term -> (string * typ) list
val dest_comb = fn: term -> term * term
val is_Bound = fn: term -> bool
val strip_abs = fn: term -> (string * typ) list * term
val dest_funT = fn: typ -> typ * typ
val dummyS = [""]: sort
val incr_bv = fn: int * int * term -> term
val dest_TVar = fn: typ -> indexname * sort
val strip_abs_body = fn: term -> term
val dummyT = Type ("dummy", []): typ
val exists_Const = fn: (string * typ -> bool) -> term -> bool
val --> = fn: typ * typ -> typ
val fold_subtypes = fn: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val lambda = fn: term -> term -> term
val size_of_typ = fn: typ -> int
val betapplys = fn: term * term list -> term
val strip_comb = fn: term -> term * term list
val propT = Type ("prop", []): typ
val subst_free = fn: (term * term) list -> term -> term
val list_comb = fn: term * term list -> term
val dest_Var = fn: term -> indexname * typ
val subst_bound = fn: term * term -> term
val exists_subtype = fn: (typ -> bool) -> typ -> bool
val maxidx_of_term = fn: term -> int
val fold_term_types = fn: (term -> typ -> 'a -> 'a) -> term -> 'a -> 'a
val map_types = fn: (typ -> typ) -> term -> term
val map_atyps = fn: (typ -> typ) -> typ -> typ
val dest_Const = fn: term -> string * typ
val aconv = fn: term * term -> bool
val dest_TFree = fn: typ -> string * sort
val subst_vars = fn:
(indexname * typ) list * (indexname * term) list -> term -> term
val type_of = fn: term -> typ
val subst_TVars = fn: (indexname * typ) list -> term -> term
val strip_all_vars = fn: term -> (string * typ) list
val is_TVar = fn: typ -> bool
val abstract_over = fn: term * term -> term
val betapply = fn: term * term -> term
val type_of1 = fn: typ list * term -> typ
val fastype_of = fn: term -> typ
val map_type_tvar = fn: (indexname * sort -> typ) -> typ -> typ
val strip_all_body = fn: term -> term
val add_loose_bnos = fn: term * int * int list -> int list
val domain_type = fn: typ -> typ
val map_type_tfree = fn: (string * sort -> typ) -> typ -> typ
val dest_Free = fn: term -> string * typ
val size_of_term = fn: term -> int
val typ_subst_atomic = fn: (typ * typ) list -> typ -> typ
val range_type = fn: typ -> typ
val exists_type = fn: (typ -> bool) -> term -> bool
val subst_Vars = fn: (indexname * term) list -> term -> term
exception TERM of string * term list
val is_Var = fn: term -> bool
val incr_boundvars = fn: int -> term -> term
val absdummy = fn: typ -> term -> term
val subst_atomic_types = fn: (typ * typ) list -> term -> term
val strip_qnt_vars = fn: string -> term -> (string * typ) list
val fastype_of1 = fn: typ list * term -> typ
val absfree = fn: string * typ -> term -> term
val loose_bnos = fn: term -> int list
val loose_bvar = fn: term * int -> bool
val is_Const = fn: term -> bool
val no_dummyT = fn: typ -> typ
val fold_types = fn: (typ -> 'a -> 'a) -> term -> 'a -> 'a
val fold_atyps = fn: (typ -> 'a -> 'a) -> typ -> 'a -> 'a
val head_of = fn: term -> term
exception TYPE of string * typ list * term list
val strip_qnt_body = fn: string -> term -> term
val subst_atomic = fn: (term * term) list -> term -> term
val is_Free = fn: term -> bool
val maxidx_of_typs = fn: typ list -> int
val fold_aterms = fn: (term -> 'a -> 'a) -> term -> 'a -> 'a
val is_first_order = fn: string list -> term -> bool
val body_type = fn: typ -> typ
val ---> = fn: typ list * typ -> typ
val binder_types = fn: typ -> typ list
val fold_atyps_sorts = fn: (typ * sort -> 'a -> 'a) -> typ -> 'a -> 'a
val map_aterms = fn: (term -> term) -> term -> term
val dest_Type = fn: typ -> string * typ list
val it = (): unit
signature BASIC_CONTEXT =
sig
structure Proof: sig type context end
structure Proof_Context:
sig
val get_global: theory -> string -> Proof.context
val init_global: theory -> Proof.context
val theory_of: Proof.context -> theory
end
exception THEORY of string * theory list
type theory
end
signature CONTEXT =
sig
val >>: (generic -> generic) -> unit
val >>>: (generic -> 'a * generic) -> 'a
structure Proof: sig type context end
structure Proof_Context:
sig
val get_global: theory -> string -> Proof.context
val init_global: theory -> Proof.context
val theory_of: Proof.context -> theory
end
val PureN: string
exception THEORY of string * theory list
val ancestors_of: theory -> theory list
val begin_thy: string -> theory list -> theory
val cases: (theory -> 'a) -> (Proof.context -> 'a) -> generic -> 'a
datatype certificate =
Certificate of theory
| Certificate_Id of theory_id
val certificate_theory: certificate -> theory
val certificate_theory_id: certificate -> theory_id
val eq_certificate: certificate * certificate -> bool
val eq_thy: theory * theory -> bool
val eq_thy_id: theory_id * theory_id -> bool
val finish_thy: theory -> theory
datatype generic = Proof of Proof.context | Theory of theory
val get_generic_context: unit -> generic option
val get_theory: theory -> string -> theory
val join_certificate: certificate * certificate -> certificate
val map_proof: (Proof.context -> Proof.context) -> generic -> generic
val map_proof_result:
(Proof.context -> 'a * Proof.context) -> generic -> 'a * generic
val map_theory: (theory -> theory) -> generic -> generic
val map_theory_result: (theory -> 'a * theory) -> generic -> 'a * generic
val mapping:
(theory -> theory) ->
(Proof.context -> Proof.context) -> generic -> generic
val mapping_result:
(theory -> 'a * theory) ->
(Proof.context -> 'a * Proof.context) -> generic -> 'a * generic
val parents_of: theory -> theory list
val pretty_abbrev_thy: theory -> Pretty.T
val pretty_thy: theory -> Pretty.T
val proof_map: (generic -> generic) -> Proof.context -> Proof.context
val proof_of: generic -> Proof.context
val proper_subthy: theory * theory -> bool
val proper_subthy_id: theory_id * theory_id -> bool
val put_generic_context: generic option -> unit
val raw_transfer: theory -> Proof.context -> Proof.context
val setmp_generic_context: generic option -> ('a -> 'b) -> 'a -> 'b
val subthy: theory * theory -> bool
val subthy_id: theory_id * theory_id -> bool
val the_generic_context: unit -> generic
val the_global_context: unit -> theory
val the_local_context: unit -> Proof.context
val the_proof: generic -> Proof.context
val the_theory: generic -> theory
type theory
val theory_id: theory -> theory_id
type theory_id
val theory_id_long_name: theory_id -> string
val theory_id_name: theory_id -> string
val theory_long_name: theory -> string
val theory_map: (generic -> generic) -> theory -> theory
val theory_name: theory -> string
val theory_of: generic -> theory
val this_theory: theory -> string -> theory
val timing: bool ref
end
signature PRIVATE_CONTEXT =
sig
val >>: (generic -> generic) -> unit
val >>>: (generic -> 'a * generic) -> 'a
structure Proof: sig type context end
structure Proof_Context:
sig
val get_global: theory -> string -> Proof.context
val init_global: theory -> Proof.context
val theory_of: Proof.context -> theory
end
structure Proof_Data:
sig
val declare: (theory -> exn) -> serial
val get: serial -> (exn -> 'a) -> Proof.context -> 'a
val put:
serial -> ('a -> exn) -> 'a -> Proof.context -> Proof.context
end
val PureN: string
exception THEORY of string * theory list
structure Theory_Data:
sig
val declare:
Position.T ->
exn ->
(exn -> exn) ->
(theory * theory -> exn * exn -> exn) -> serial
val get: serial -> (exn -> 'a) -> theory -> 'a
val put: serial -> ('a -> exn) -> 'a -> theory -> theory
end
val ancestors_of: theory -> theory list
val begin_thy: string -> theory list -> theory
val cases: (theory -> 'a) -> (Proof.context -> 'a) -> generic -> 'a
datatype certificate =
Certificate of theory
| Certificate_Id of theory_id
val certificate_theory: certificate -> theory
val certificate_theory_id: certificate -> theory_id
val eq_certificate: certificate * certificate -> bool
val eq_thy: theory * theory -> bool
val eq_thy_id: theory_id * theory_id -> bool
val finish_thy: theory -> theory
datatype generic = Proof of Proof.context | Theory of theory
val get_generic_context: unit -> generic option
val get_theory: theory -> string -> theory
val join_certificate: certificate * certificate -> certificate
val map_proof: (Proof.context -> Proof.context) -> generic -> generic
val map_proof_result:
(Proof.context -> 'a * Proof.context) -> generic -> 'a * generic
val map_theory: (theory -> theory) -> generic -> generic
val map_theory_result: (theory -> 'a * theory) -> generic -> 'a * generic
val mapping:
(theory -> theory) ->
(Proof.context -> Proof.context) -> generic -> generic
val mapping_result:
(theory -> 'a * theory) ->
(Proof.context -> 'a * Proof.context) -> generic -> 'a * generic
val parents_of: theory -> theory list
val pretty_abbrev_thy: theory -> Pretty.T
val pretty_thy: theory -> Pretty.T
val proof_map: (generic -> generic) -> Proof.context -> Proof.context
val proof_of: generic -> Proof.context
val proper_subthy: theory * theory -> bool
val proper_subthy_id: theory_id * theory_id -> bool
val put_generic_context: generic option -> unit
val raw_transfer: theory -> Proof.context -> Proof.context
val setmp_generic_context: generic option -> ('a -> 'b) -> 'a -> 'b
val subthy: theory * theory -> bool
val subthy_id: theory_id * theory_id -> bool
val the_generic_context: unit -> generic
val the_global_context: unit -> theory
val the_local_context: unit -> Proof.context
val the_proof: generic -> Proof.context
val the_theory: generic -> theory
type theory
val theory_id: theory -> theory_id
type theory_id
val theory_id_long_name: theory_id -> string
val theory_id_name: theory_id -> string
val theory_long_name: theory -> string
val theory_map: (generic -> generic) -> theory -> theory
val theory_name: theory -> string
val theory_of: generic -> theory
val this_theory: theory -> string -> theory
val timing: bool ref
end
structure Context: PRIVATE_CONTEXT
structure Basic_Context: BASIC_CONTEXT
type theory
structure Proof: sig type context end
structure Proof_Context:
sig
val get_global: theory -> string -> Proof.context
val init_global: theory -> Proof.context
val theory_of: Proof.context -> theory
end
exception THEORY of string * theory list
signature THEORY_DATA'_ARGS =
sig
type T
val empty: T
val extend: T -> T
val merge: theory * theory -> T * T -> T
end
signature THEORY_DATA_ARGS =
sig type T val empty: T val extend: T -> T val merge: T * T -> T end
signature THEORY_DATA =
sig
type T
val get: theory -> T
val map: (T -> T) -> theory -> theory
val put: T -> theory -> theory
end
Warning: Matches are not exhaustive.
fn Data x => Data (Data.extend x)
At (line 571 of "context.ML")
Warning: Matches are not exhaustive.
fn (Data x1, Data x2) => Data (Data.merge thys (x1, ...))
At (line 572 of "context.ML")
Warning: Matches are not exhaustive.
fn Data x => x
At (line 574 of "context.ML")
functor Theory_Data' (Data: THEORY_DATA'_ARGS): THEORY_DATA
functor Theory_Data (Data: THEORY_DATA_ARGS): THEORY_DATA
signature PROOF_DATA_ARGS = sig type T val init: theory -> T end
signature PROOF_DATA =
sig
type T
val get: Proof.context -> T
val map: (T -> T) -> Proof.context -> Proof.context
val put: T -> Proof.context -> Proof.context
end
Warning: Matches are not exhaustive.
fn Data x => x
At (line 615 of "context.ML")
functor Proof_Data (Data: PROOF_DATA_ARGS): PROOF_DATA
signature GENERIC_DATA_ARGS =
sig type T val empty: T val extend: T -> T val merge: T * T -> T end
signature GENERIC_DATA =
sig
type T
val get: Context.generic -> T
val map: (T -> T) -> Context.generic -> Context.generic
val put: T -> Context.generic -> Context.generic
end
functor Generic_Data (Data: GENERIC_DATA_ARGS): GENERIC_DATA
structure Context: CONTEXT
val it = (): unit
signature CONTEXT_POSITION =
sig
val is_really_visible: Proof.context -> bool
val is_reported: Proof.context -> Position.T -> bool
val is_reported_generic: Context.generic -> Position.T -> bool
val is_visible: Proof.context -> bool
val is_visible_generic: Context.generic -> bool
val is_visible_global: theory -> bool
val not_really: Proof.context -> Proof.context
val report: Proof.context -> Position.T -> Markup.T -> unit
val report_generic: Context.generic -> Position.T -> Markup.T -> unit
val report_text:
Proof.context -> Position.T -> Markup.T -> string -> unit
val reported_text:
Proof.context -> Position.T -> Markup.T -> string -> string
val reports: Proof.context -> Position.report list -> unit
val reports_text: Proof.context -> Position.report_text list -> unit
val restore_visible: Proof.context -> Proof.context -> Proof.context
val restore_visible_generic:
Context.generic -> Context.generic -> Context.generic
val restore_visible_global: theory -> theory -> theory
val set_visible: bool -> Proof.context -> Proof.context
val set_visible_generic: bool -> Context.generic -> Context.generic
val set_visible_global: bool -> theory -> theory
end
structure Context_Position: CONTEXT_POSITION
val it = (): unit
signature OPTIONS =
sig
type T
val bool: T -> string -> bool
val boolT: string
val declare:
{name: string, pos: Position.T, typ: string, value: string} -> T -> T
val decode: XML.body -> T
val default: unit -> T
val default_bool: string -> bool
val default_int: string -> int
val default_markup: string * Position.T -> Markup.T
val default_put_bool: string -> bool -> unit
val default_put_int: string -> int -> unit
val default_put_real: string -> real -> unit
val default_put_string: string -> string -> unit
val default_real: string -> real
val default_seconds: string -> Time.time
val default_string: string -> string
val default_typ: string -> string
val empty: T
val get_default: string -> string
val int: T -> string -> int
val intT: string
val load_default: unit -> unit
val markup: T -> string * Position.T -> Markup.T
val names: T -> string list
val put_bool: string -> bool -> T -> T
val put_default: string -> string -> unit
val put_int: string -> int -> T -> T
val put_real: string -> real -> T -> T
val put_string: string -> string -> T -> T
val real: T -> string -> real
val realT: string
val reset_default: unit -> unit
val seconds: T -> string -> Time.time
val set_default: T -> unit
val string: T -> string -> string
val stringT: string
val typ: T -> string -> string
val unknownT: string
val update: string -> string -> T -> T
end
structure Options: OPTIONS
val it = (): unit
signature CONFIG =
sig
type 'a T
val bool: raw -> bool T
val declare: string * Position.T -> (Context.generic -> value) -> raw
val declare_option: string * Position.T -> raw
val get: Proof.context -> 'a T -> 'a
val get_generic: Context.generic -> 'a T -> 'a
val get_global: theory -> 'a T -> 'a
val int: raw -> int T
val map: 'a T -> ('a -> 'a) -> Proof.context -> Proof.context
val map_generic: 'a T -> ('a -> 'a) -> Context.generic -> Context.generic
val map_global: 'a T -> ('a -> 'a) -> theory -> theory
val name_of: 'a T -> string
val pos_of: 'a T -> Position.T
val print_type: value -> string
val print_value: value -> string
val put: 'a T -> 'a -> Proof.context -> Proof.context
val put_generic: 'a T -> 'a -> Context.generic -> Context.generic
val put_global: 'a T -> 'a -> theory -> theory
type raw = value T
val real: raw -> real T
val string: raw -> string T
datatype value =
Bool of bool
| Int of int
| Real of real
| String of string
end
Warning: Matches are not exhaustive.
fn Bool b => b
At (line 86 of "config.ML")
Warning: Matches are not exhaustive.
fn Int i => i
At (line 87 of "config.ML")
Warning: Matches are not exhaustive.
fn Real x => x
At (line 88 of "config.ML")
Warning: Matches are not exhaustive.
fn String s => s
At (line 89 of "config.ML")
structure Config: CONFIG
val it = (): unit
val it = (): unit
signature EXN_PROPERTIES =
sig
val get: exn -> Properties.T
val position: exn -> Position.T
val position_of_polyml_location:
ML_Compiler0.polyml_location -> Position.T
val update: Properties.entry list -> exn -> exn
end
Warning: Handler catches all exceptions.
PolyML.raiseWithLocation (exn, loc') handle exn' => exn'
At (line 67 of "ML/exn_properties.ML")
structure Exn_Properties: EXN_PROPERTIES
val it = (): unit
signature ML_STATISTICS = sig val get: unit -> Properties.T end
structure ML_Statistics: ML_STATISTICS
val it = (): unit
structure Thread_Data_Virtual: THREAD_DATA
val it = (): unit
signature STANDARD_THREAD =
sig
val attributes: params -> Thread.threadAttribute list
val fork: params -> (unit -> unit) -> Thread.thread
val get_name: unit -> string option
val interrupt_unsynchronized: Thread.thread -> unit
val is_self: Thread.thread -> bool
val join: Thread.thread -> unit
type params = {interrupts: bool, name: string, stack_limit: int option}
val the_name: unit -> string
end
Warning: Handler catches all exceptions.
(set_name (#name params); body ())
handle exn => if Exn.is_interrupt exn then () else Exn.reraise exn
At (line 60 of "Concurrent/standard_thread.ML")
structure Standard_Thread: STANDARD_THREAD
val it = (): unit
signature SINGLE_ASSIGNMENT =
sig
val assign: 'a var -> 'a -> unit
val await: 'a var -> 'a
val peek: 'a var -> 'a option
val var: string -> 'a var
type 'a var
end
structure Single_Assignment: SINGLE_ASSIGNMENT
val it = (): unit
signature PAR_EXN =
sig
val dest: exn -> exn list option
val identify: Properties.entry list -> exn -> exn
val is_interrupted: 'a Exn.result list -> bool
val make: exn list -> exn
val release_all: 'a Exn.result list -> 'a list
val release_first: 'a Exn.result list -> 'a list
val the_serial: exn -> int
end
structure Par_Exn: PAR_EXN
val it = (): unit
signature TASK_QUEUE =
sig
val all_passive: queue -> bool
val cancel: queue -> group -> Thread.thread list
val cancel_all: queue -> group list * Thread.thread list
val cancel_group: group -> exn -> unit
val dequeue:
Thread.thread ->
bool -> queue -> (task * (bool -> bool) list) option * queue
val dequeue_deps:
Thread.thread ->
task list ->
queue -> ((task * (bool -> bool) list) option * task list) * queue
val dequeue_passive:
Thread.thread -> task -> queue -> bool option * queue
val dummy_task: task
val empty: queue
val enqueue:
string ->
group -> task list -> int -> (bool -> bool) -> queue -> task * queue
val enqueue_passive:
group -> string -> (unit -> bool) -> queue -> task * queue
val enroll: Thread.thread -> string -> group -> queue -> task * queue
val eq_group: group * group -> bool
val extend: task -> (bool -> bool) -> queue -> queue option
val finish: task -> queue -> bool * queue
type group
val group_id: group -> int
val group_of_task: task -> group
val group_status: group -> exn list
val group_tasks: queue -> group list -> task list
val is_canceled: group -> bool
val joining: task -> (unit -> 'a) -> 'a
val known_task: queue -> task -> bool
val name_of_task: task -> string
val new_group: group option -> group
val pri_of_task: task -> int
type queue
val running: task -> (unit -> 'a) -> 'a
val status:
queue ->
{passive: int, pending: int, ready: int, running: int, urgent: int}
val str_of_group: group -> string
val str_of_groups: group -> string
val str_of_task: task -> string
val str_of_task_groups: task -> string
type task
val task_statistics: task -> Properties.T
val urgent_pri: int
val waiting: task -> task list -> (unit -> 'a) -> 'a
end
structure Task_Queue: TASK_QUEUE
val it = (): unit
signature FUTURE =
sig
val ML_statistics: bool ref
val cancel: 'a future -> unit
val cancel_group: group -> unit
val cond_forks: params -> (unit -> 'a) list -> 'a future list
val default_params: params
val error_message:
Position.T -> (serial * string) * string option -> unit
val fork: (unit -> 'a) -> 'a future
val forks: params -> (unit -> 'a) list -> 'a future list
val fulfill: 'a future -> 'a -> unit
val fulfill_result: 'a future -> 'a Exn.result -> unit
type 'a future
type group
val identify_result: Position.T -> 'a Exn.result -> 'a Exn.result
val interruptible_task: ('a -> 'b) -> 'a -> 'b
val is_finished: 'a future -> bool
val join: 'a future -> 'a
val join_result: 'a future -> 'a Exn.result
val join_results: 'a future list -> 'a Exn.result list
val joins: 'a future list -> 'a list
val map: ('a -> 'b) -> 'a future -> 'b future
val new_group: group option -> group
type params =
{deps: task list,
group: group option, interrupts: bool, name: string, pri: int}
val peek: 'a future -> 'a Exn.result option
val promise: (unit -> unit) -> 'a future
val promise_name: string -> (unit -> unit) -> 'a future
val shutdown: unit -> unit
val snapshot: group list -> task list
type task
val task_context: string -> group -> ('a -> 'b) -> 'a -> 'b
val task_of: 'a future -> task
val the_worker_group: unit -> group
val value: 'a -> 'a future
val value_result: 'a Exn.result -> 'a future
val worker_group: unit -> group option
val worker_subgroup: unit -> group
val worker_task: unit -> task option
end
Warning: Handler catches all exceptions.
let val now = Time.now (); val tick = ... <= ...; val ... = ...; val ...;
... in continue end
handle
exn =>
if Exn.is_interrupt exn then (... ... (fn ...); ... ...; ...) else
Exn.reraise exn
At (line 352 of "Concurrent/future.ML")
Warning: Handler catches all exceptions.
assign_result group result Exn.interrupt_exn
handle
Fail _ => true |
exn => if Exn.is_interrupt exn then raise ... ... else Exn.reraise exn
At (line 598 of "Concurrent/future.ML")
structure Future: FUTURE
type 'a future
val it = (): unit
signature EVENT_TIMER =
sig
val cancel: request -> bool
val future: Time.time -> unit future
val request: Time.time -> (unit -> unit) -> request
eqtype request
val shutdown: unit -> unit
end
Warning: Handler catches all exceptions.
restore_attributes (fn () => ... ...) ()
handle
exn =>
if Exn.is_interrupt exn then Synchronized.change state (fn ... => ...)
else ()
At (line 122 of "Concurrent/event_timer.ML")
structure Event_Timer: EVENT_TIMER
val it = (): unit
signature TIMEOUT =
sig
exception TIMEOUT of Time.time
val apply: Time.time -> ('a -> 'b) -> 'a -> 'b
val print: Time.time -> string
end
structure Timeout: TIMEOUT
val it = (): unit
signature LAZY =
sig
val force: 'a lazy -> 'a
val force_list: 'a lazy list -> 'a list
val force_result: 'a lazy -> 'a Exn.result
val future: Future.params -> 'a lazy -> 'a future
val is_finished: 'a lazy -> bool
val is_running: 'a lazy -> bool
val lazy: (unit -> 'a) -> 'a lazy
type 'a lazy
val lazy_name: string -> (unit -> 'a) -> 'a lazy
val map: ('a -> 'b) -> 'a lazy -> 'b lazy
val peek: 'a lazy -> 'a Exn.result option
val value: 'a -> 'a lazy
end
structure Lazy: LAZY
type 'a lazy
val it = (): unit
signature PAR_LIST =
sig
val exists: ('a -> bool) -> 'a list -> bool
val find_some: ('a -> bool) -> 'a list -> 'a option
val forall: ('a -> bool) -> 'a list -> bool
val get_some: ('a -> 'b option) -> 'a list -> 'b option
val managed_results:
string -> ('a -> 'b) -> 'a list -> 'b Exn.result list
val map: ('a -> 'b) -> 'a list -> 'b list
val map_independent: ('a -> 'b) -> 'a list -> 'b list
val map_name: string -> ('a -> 'b) -> 'a list -> 'b list
end
Warning: Handler catches all exceptions.
restore_attributes Future.join_results futures
handle
exn =>
(
if Exn.is_interrupt exn then Future.cancel_group group else ();
Exn.reraise exn
)
At (line 48 of "Concurrent/par_list.ML")
structure Par_List: PAR_LIST
val it = (): unit
signature MAILBOX =
sig
type 'a T
val await_empty: 'a T -> unit
val create: unit -> 'a T
val receive: Time.time option -> 'a T -> 'a list
val send: 'a T -> 'a -> unit
end
structure Mailbox: MAILBOX
val it = (): unit
signature CACHE =
sig
val create:
'a ->
('a -> 'b -> 'c lazy option) ->
('b * 'c lazy -> 'a -> 'a) -> ('b -> 'c) -> 'b -> 'c
end
structure Cache: CACHE
val it = (): unit
signature ACTIVE =
sig
val dialog: unit -> (string -> Markup.T) * string future
val dialog_result: serial -> string -> unit
val dialog_text: unit -> (string -> string) * string future
val make_markup:
string -> {implicit: bool, properties: Properties.T} -> Markup.T
val markup: string -> string -> string
val markup_implicit: string -> string -> string
val sendback_markup_command: string -> string
val sendback_markup_properties: Properties.T -> string -> string
end
structure Active: ACTIVE
val it = (): unit
val it = (): unit
signature TYPE_ANNOTATION =
sig
val clean: typ -> typ
val fastype_of: typ list -> term -> typ
val ignore_free_types: term -> term
val ignore_type: typ -> typ
val is_ignored: typ -> bool
val is_omitted: typ -> bool
val smash: typ -> typ
end
structure Type_Annotation: TYPE_ANNOTATION
val it = (): unit
signature TERM_POSITION =
sig
val decode: string -> Position.T option
val decode_position: term -> (Position.T * typ) option
val decode_positionS: sort -> Position.T list * sort
val decode_positionT: typ -> Position.T option
val encode: Position.T -> string
val is_position: term -> bool
val is_positionT: typ -> bool
val markers: string list
val pretty: Position.T -> Pretty.T
val strip_positions: term -> term
end
structure Term_Position: TERM_POSITION
val it = (): unit
signature LEXICON =
sig
structure Syntax:
sig
val const: string -> term
val free: string -> term
val var: indexname -> term
end
val dummy_type: term
val eof: token
val explode_str: string * Position.T -> Symbol_Pos.T list
val explode_string: string * Position.T -> Symbol_Pos.T list
val fun_type: term
val implode_str: string list -> string
val implode_string: string list -> string
val is_eof: token -> bool
val is_marked: string -> bool
val is_proper: token -> bool
val is_terminal: string -> bool
val is_tid: string -> bool
val literal_markup: string -> Markup.T
val mark_class: string -> string
val mark_const: string -> string
val mark_fixed: string -> string
val mark_type: string -> string
val matching_tokens: token * token -> bool
val mk_eof: Position.T -> token
val pos_of_token: token -> Position.T
val predef_term: string -> token option
val read_float: string -> {exp: int, mant: int}
val read_indexname: string -> indexname
val read_int: string -> int option
val read_nat: string -> int option
val read_num: string -> {leading_zeros: int, radix: int, value: int}
val read_var: string -> term
val read_variable: string -> indexname option
val report_of_token: token -> Position.report
val reported_token_range: Proof.context -> token -> string
val scan_bin: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_hex: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_id: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_longid:
Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_tid: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_tvar: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val scan_var: Symbol_Pos.T list -> Symbol_Pos.T list * Symbol_Pos.T list
val stopper: token Scan.stopper
val str_of_token: token -> string
val terminals: string list
datatype token = Token of token_kind * string * Position.range
datatype token_kind =
Cartouche
| Comment
| EOF
| FloatSy
| IdentSy
| Literal
| LongIdentSy
| NumSy
| Space
| StrSy
| StringSy
| TFreeSy
| TVarSy
| VarSy
val tokenize: Scan.lexicon -> bool -> Symbol_Pos.T list -> token list
val unmark:
{case_class: string -> 'a,
case_const: string -> 'a,
case_default: string -> 'a,
case_fixed: string -> 'a, case_type: string -> 'a} -> string -> 'a
val unmark_class: string -> string
val unmark_const: string -> string
val unmark_fixed: string -> string
val unmark_type: string -> string
val valued_token: token -> bool
end
structure Lexicon: LEXICON
val it = (): unit
signature AST =
sig
exception AST of string * ast list
datatype ast = Appl of ast list | Constant of string | Variable of string
val fold_ast: string -> ast list -> ast
val fold_ast_p: string -> ast list * ast -> ast
val head_of_rule: ast * ast -> string
val mk_appl: ast -> ast list -> ast
val normalize:
Proof.context -> (string -> (ast * ast) list) -> ast -> ast
val pretty_ast: ast -> Pretty.T
val pretty_rule: ast * ast -> Pretty.T
val rule_error: ast * ast -> string option
val stats: bool Config.T
val stats_raw: Config.raw
val strip_positions: ast -> ast
val trace: bool Config.T
val trace_raw: Config.raw
val unfold_ast: string -> ast -> ast list
val unfold_ast_p: string -> ast -> ast list * ast
end
structure Ast: AST
val it = (): unit
signature SYNTAX_EXT =
sig
val block_indent: int -> block_info
type block_info =
{consistent: bool, indent: int, markup: Markup.T, unbreakable: bool}
val chain_pri: int
val delims_of: xprod list -> string list list
val eq_trfun: ('a * stamp) * ('a * stamp) -> bool
val escape: string -> string
datatype mfix =
Mfix of
Symbol_Pos.T list * typ * string * int list * int * Position.T
val mfix_args: Symbol_Pos.T list -> int
val mixfix_args: Input.source -> int
val mk_trfun: string * 'a -> string * ('a * stamp)
val stamp_trfun: stamp -> string * 'a -> string * ('a * stamp)
val syn_ext:
mfix list ->
(string * string) list ->
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list *
(string * ((Proof.context -> term list -> term) * stamp)) list *
(string * ((Proof.context -> typ -> term list -> term) * stamp))
list *
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list ->
(Ast.ast * Ast.ast) list * (Ast.ast * Ast.ast) list -> syn_ext
datatype syn_ext =
Syn_Ext of
{consts: (string * string) list,
parse_ast_translation:
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list,
parse_rules: (Ast.ast * Ast.ast) list,
parse_translation:
(string * ((Proof.context -> term list -> term) * stamp)) list,
print_ast_translation:
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list,
print_rules: (Ast.ast * Ast.ast) list,
print_translation:
(string * ((Proof.context -> typ -> term list -> term) * stamp)
) list, xprods: xprod list}
val syn_ext':
string list ->
mfix list ->
(string * string) list ->
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list *
(string * ((Proof.context -> term list -> term) * stamp)) list *
(string * ((Proof.context -> typ -> term list -> term) * stamp))
list *
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp))
list ->
(Ast.ast * Ast.ast) list * (Ast.ast * Ast.ast) list -> syn_ext
val syn_ext_rules:
(Ast.ast * Ast.ast) list * (Ast.ast * Ast.ast) list -> syn_ext
val syn_ext_trfuns:
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp)) list *
(string * ((Proof.context -> term list -> term) * stamp)) list *
(string * ((Proof.context -> typ -> term list -> term) * stamp)) list
* (string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp)) list
-> syn_ext
val typ_to_nonterm: typ -> string
datatype xprod = XProd of string * xsymb list * string * int
datatype xsymb =
Argument of string * int
| Bg of block_info
| Brk of int
| Delim of string
| En
| Space of string
end
structure Syntax_Ext: SYNTAX_EXT
val it = (): unit
signature PARSER =
sig
exception PARSETREE of parsetree
val branching_level: int Config.T
val empty_gram: gram
val extend_gram: Syntax_Ext.xprod list -> gram -> gram
type gram
val guess_infix_lr: gram -> string -> (string * bool * bool * int) option
val make_gram: Syntax_Ext.xprod list -> gram
val parse: gram -> string -> Lexicon.token list -> parsetree list
datatype parsetree =
Node of string * parsetree list
| Tip of Lexicon.token
val pretty_gram: gram -> Pretty.T list
val pretty_parsetree: parsetree -> Pretty.T
end
Warning: Value identifier (a) has not been referenced.
At (line 614 of "Syntax/parser.ML")
Warning: Matches are not exhaustive.
fun
movedot_term c (...)
=
if ... ... orelse ... <> ... then (A, ...) else (A, ...)
At (line 614 of "Syntax/parser.ML")
Warning: Matches are not exhaustive.
fun movedot_nonterm tt (...) = (A, j, ...)
At (line 619 of "Syntax/parser.ML")
Warning: Value identifier (A) has not been referenced.
At (line 623 of "Syntax/parser.ML")
Warning: Matches are not exhaustive.
fun
movedot_lambda [] _ = [] |
movedot_lambda (... :: ...) ...
=
if ... <= ... then ... :: ... else ... ...
At (line 622 of "Syntax/parser.ML")
structure Parser: PARSER
val it = (): unit
signature BASIC_SYNTAX_TRANS = sig val eta_contract: bool Config.T end
signature SYNTAX_TRANS =
sig
val abs_tr: term list -> term
val abs_tr': Proof.context -> term -> term
val antiquote_tr: string -> term -> term
val antiquote_tr': string -> term -> term
val applC_ast_tr': Ast.ast * Ast.ast list -> Ast.ast
val appl_ast_tr': Ast.ast * Ast.ast list -> Ast.ast
val atomic_abs_tr': string * typ * term -> term * term
val bound_vars: (string * typ) list -> term -> term
val bracketsN: string
val const_abs_tr': term -> term
val dependent_tr': string * string -> term list -> term
val eta_contract: bool Config.T
val eta_contract_raw: Config.raw
val get_idents:
Proof.context -> {fixes: string list, structs: string list}
val mark_bound_abs: string * typ -> term
val mark_bound_body: string * typ -> term
val mk_binder_tr:
string * string -> string * (Proof.context -> term list -> term)
val mk_binder_tr':
string * string -> string * (Proof.context -> term list -> term)
val no_brackets: unit -> bool
val no_bracketsN: string
val no_type_brackets: unit -> bool
val no_type_bracketsN: string
val non_typed_tr':
(Proof.context -> term list -> term) ->
Proof.context -> typ -> term list -> term
val preserve_binder_abs2_tr':
string -> string -> string * (Proof.context -> term list -> term)
val preserve_binder_abs_tr':
string -> string -> string * (Proof.context -> term list -> term)
val pure_parse_ast_translation:
(string * (Proof.context -> Ast.ast list -> Ast.ast)) list
val pure_parse_translation:
(string * (Proof.context -> term list -> term)) list
val pure_print_ast_translation:
(string * (Proof.context -> Ast.ast list -> Ast.ast)) list
val put_idents:
{fixes: string list, structs: string list} ->
Proof.context -> Proof.context
val quote_antiquote_tr:
string ->
string -> string -> string * (Proof.context -> term list -> term)
val quote_antiquote_tr':
string ->
string -> string -> string * (Proof.context -> term list -> term)
val quote_tr: string -> term -> term
val quote_tr': string -> term -> term
val tappl_ast_tr': Ast.ast * Ast.ast list -> Ast.ast
val type_bracketsN: string
val update_name_tr': term -> term
val variant_abs: string * typ * term -> string * term
val variant_abs': string * typ * term -> string * term
end
Warning: Pattern is not exhaustive.
val [xT] = Term.rename_wrt_term t [(x, ...)]
At (line 333 of "Syntax/syntax_trans.ML")
Warning: Matches are not exhaustive.
fn
Abs abs :: ts =>
let val (...) = ... ... in list_comb (... $ ..., ...) end
At (line 366 of "Syntax/syntax_trans.ML")
Warning: Matches are not exhaustive.
fn
A :: Abs abs :: ts =>
let val (...) = ... ... in list_comb (... $ ..., ...) end
At (line 370 of "Syntax/syntax_trans.ML")
structure Syntax_Trans: SYNTAX_TRANS
structure Basic_Syntax_Trans: BASIC_SYNTAX_TRANS
val eta_contract =
Config
{get_value = fn, map_value = fn, name = "eta_contract", pos =
{line=300, file=Syntax/syntax_trans.ML}}: bool Config.T
val it = (): unit
signature BASIC_MIXFIX =
sig
datatype mixfix =
Binder of Input.source * int * int * Position.range
| Infix of Input.source * int * Position.range
| Infixl of Input.source * int * Position.range
| Infixr of Input.source * int * Position.range
| Mixfix of Input.source * int list * int * Position.range
| NoSyn
| Structure of Position.range
end
signature MIXFIX =
sig
val binder_name: string -> string
val default_constraint: mixfix -> typ
val equal: mixfix * mixfix -> bool
val is_empty: mixfix -> bool
val make_type: int -> typ
val mixfix: string -> mixfix
datatype mixfix =
Binder of Input.source * int * int * Position.range
| Infix of Input.source * int * Position.range
| Infixl of Input.source * int * Position.range
| Infixr of Input.source * int * Position.range
| Mixfix of Input.source * int list * int * Position.range
| NoSyn
| Structure of Position.range
val mixfix_args: mixfix -> int
val pos_of: mixfix -> Position.T
val pretty_mixfix: mixfix -> Pretty.T
val range_of: mixfix -> Position.range
val reset_pos: mixfix -> mixfix
val syn_ext_consts:
string list -> (string * typ * mixfix) list -> Syntax_Ext.syn_ext
val syn_ext_types: (string * typ * mixfix) list -> Syntax_Ext.syn_ext
end
structure Mixfix: MIXFIX
structure Basic_Mixfix: BASIC_MIXFIX
datatype mixfix =
Binder of Input.source * int * int * Position.range
| Infix of Input.source * int * Position.range
| Infixl of Input.source * int * Position.range
| Infixr of Input.source * int * Position.range
| Mixfix of Input.source * int list * int * Position.range
| NoSyn
| Structure of Position.range
val it = (): unit
signature BASIC_PRINTER =
sig
val pretty_priority: int Config.T
val show_brackets: bool Config.T
val show_markup: bool Config.T
val show_question_marks: bool Config.T
val show_sorts: bool Config.T
val show_structs: bool Config.T
val show_types: bool Config.T
end
signature PRINTER =
sig
val empty_prtabs: prtabs
val merge_prtabs: prtabs -> prtabs -> prtabs
val pretty_priority: int Config.T
val pretty_term_ast:
bool ->
Proof.context ->
prtabs ->
(string -> Proof.context -> Ast.ast list -> Ast.ast) ->
(string -> Ast.ast list -> Pretty.T option) ->
(string -> Markup.T list * string) ->
Ast.ast -> Pretty.T list
val pretty_typ_ast:
Proof.context ->
prtabs ->
(string -> Proof.context -> Ast.ast list -> Ast.ast) ->
(string -> Ast.ast list -> Pretty.T option) ->
(string -> Markup.T list * string) -> Ast.ast -> Pretty.T list
type prtabs
val remove_prtabs: string -> Syntax_Ext.xprod list -> prtabs -> prtabs
val show_brackets: bool Config.T
val show_brackets_raw: Config.raw
val show_markup: bool Config.T
val show_markup_default: bool ref
val show_markup_raw: Config.raw
val show_question_marks: bool Config.T
val show_question_marks_raw: Config.raw
val show_sorts: bool Config.T
val show_sorts_raw: Config.raw
val show_structs: bool Config.T
val show_structs_raw: Config.raw
val show_type_emphasis: bool Config.T
val show_types: bool Config.T
val show_types_raw: Config.raw
val type_emphasis: Proof.context -> typ -> bool
val update_prtabs: string -> Syntax_Ext.xprod list -> prtabs -> prtabs
end
Warning: Matches are not exhaustive.
fun
synT _ (...) = ([], args) |
synT m ... = let val ... in (...) end |
synT ... = let ... in ... end |
synT ... = ... |
... and
parT m ... = #1 (... ...) and
atomT ... = ... ... and
prefixT ... = ... | ... and
... and
...
At (line 184 of "Syntax/printer.ML")
Warning: Matches are not exhaustive.
fun
synT _ (...) = ([], args) |
synT m ... = let val ... in (...) end |
synT ... = let ... in ... end |
synT ... = ... |
... and
parT m ... = #1 (... ...) and
atomT ... = ... ... and
prefixT ... = ... | ... and
... and
...
At (line 229 of "Syntax/printer.ML")
structure Printer: PRINTER
structure Basic_Printer: BASIC_PRINTER
val show_markup =
Config
{get_value = fn, map_value = fn, name = "show_markup", pos =
{line=62, file=Syntax/printer.ML}}: bool Config.T
val show_types =
Config
{get_value = fn, map_value = fn, name = "show_types", pos =
{line=54, file=Syntax/printer.ML}}: bool Config.T
val show_question_marks =
Config
{get_value = fn, map_value = fn, name = "show_question_marks", pos =
{line=69, file=Syntax/printer.ML}}: bool Config.T
val show_brackets =
Config
{get_value = fn, map_value = fn, name = "show_brackets", pos =
{line=51, file=Syntax/printer.ML}}: bool Config.T
val show_sorts =
Config
{get_value = fn, map_value = fn, name = "show_sorts", pos =
{line=57, file=Syntax/printer.ML}}: bool Config.T
val pretty_priority =
Config
{get_value = fn, map_value = fn, name = "Syntax.pretty_priority", pos =
{line=172, file=Syntax/printer.ML}}: int Config.T
val show_structs =
Config
{get_value = fn, map_value = fn, name = "show_structs", pos =
{line=66, file=Syntax/printer.ML}}: bool Config.T
val it = (): unit
signature SYNTAX =
sig
val ambiguity_limit: int Config.T
val ambiguity_limit_raw: Config.raw
val ambiguity_warning: bool Config.T
val ambiguity_warning_raw: Config.raw
val check_prop: Proof.context -> term -> term
val check_props: Proof.context -> term list -> term list
val check_sort: Proof.context -> sort -> sort
val check_term: Proof.context -> term -> term
val check_terms: Proof.context -> term list -> term list
val check_typ: Proof.context -> typ -> typ
val check_typs: Proof.context -> typ list -> typ list
val const: string -> term
val empty_syntax: syntax
val encode_input: Input.source -> XML.tree
val eq_syntax: syntax * syntax -> bool
val force_syntax: syntax -> unit
val free: string -> term
val guess_infix: syntax -> string -> mixfix option
val implode_input: Input.source -> string
val init_pretty: Context.generic -> Proof.context
val init_pretty_global: theory -> Proof.context
val install_operations: operations -> theory -> theory
val is_keyword: syntax -> string -> bool
val is_pretty_global: Proof.context -> bool
val lookup_const: syntax -> string -> string option
val map_trrule: ('a -> 'b) -> 'a trrule -> 'b trrule
val merge_syntax: syntax * syntax -> syntax
type mode
val mode_default: mode
val mode_input: mode
type operations
val parse:
syntax -> string -> Lexicon.token list -> Parser.parsetree list
val parse_ast_translation:
syntax -> string -> (Proof.context -> Ast.ast list -> Ast.ast) option
val parse_input:
Proof.context ->
(XML.tree list -> 'a) ->
(bool -> Markup.T) ->
(Symbol_Pos.T list * Position.T -> 'a) -> string -> 'a
val parse_prop: Proof.context -> string -> term
val parse_rules: syntax -> string -> (Ast.ast * Ast.ast) list
val parse_sort: Proof.context -> string -> sort
val parse_term: Proof.context -> string -> term
val parse_translation:
syntax -> string -> (Proof.context -> term list -> term) option
val parse_typ: Proof.context -> string -> typ
val pretty_arity: Proof.context -> arity -> Pretty.T
val pretty_classrel: Proof.context -> class list -> Pretty.T
val pretty_sort: Proof.context -> sort -> Pretty.T
val pretty_sort_global: theory -> sort -> Pretty.T
val pretty_term: Proof.context -> term -> Pretty.T
val pretty_term_global: theory -> term -> Pretty.T
val pretty_typ: Proof.context -> typ -> Pretty.T
val pretty_typ_global: theory -> typ -> Pretty.T
val print_ast_translation:
syntax -> string -> Proof.context -> Ast.ast list -> Ast.ast
val print_gram: syntax -> unit
val print_rules: syntax -> string -> (Ast.ast * Ast.ast) list
val print_syntax: syntax -> unit
val print_trans: syntax -> unit
val print_translation:
syntax -> string -> Proof.context -> typ -> term list -> term
val prtabs: syntax -> Printer.prtabs
val read_input: string -> Input.source
val read_input_pos: string -> Position.T
val read_prop: Proof.context -> string -> term
val read_prop_global: theory -> string -> term
val read_props: Proof.context -> string list -> term list
val read_sort: Proof.context -> string -> sort
val read_sort_global: theory -> string -> sort
val read_term: Proof.context -> string -> term
val read_term_global: theory -> string -> term
val read_terms: Proof.context -> string list -> term list
val read_typ: Proof.context -> string -> typ
val read_typ_global: theory -> string -> typ
val read_typs: Proof.context -> string list -> typ list
val remove_trrules: Ast.ast trrule list -> syntax -> syntax
val root: string Config.T
val set_pretty_global: bool -> Proof.context -> Proof.context
val string_of_arity: Proof.context -> arity -> string
val string_of_classrel: Proof.context -> class list -> string
val string_of_sort: Proof.context -> sort -> string
val string_of_sort_global: theory -> sort -> string
val string_of_term: Proof.context -> term -> string
val string_of_term_global: theory -> term -> string
val string_of_typ: Proof.context -> typ -> string
val string_of_typ_global: theory -> typ -> string
type syntax
val tokenize: syntax -> bool -> Symbol_Pos.T list -> Lexicon.token list
datatype 'a trrule =
Parse_Print_Rule of 'a * 'a
| Parse_Rule of 'a * 'a
| Print_Rule of 'a * 'a
val uncheck_arity: Proof.context -> arity -> arity
val uncheck_classrel: Proof.context -> class list -> class list
val uncheck_sort: Proof.context -> sort -> sort
val uncheck_terms: Proof.context -> term list -> term list
val uncheck_typs: Proof.context -> typ list -> typ list
val unparse_arity: Proof.context -> arity -> Pretty.T
val unparse_classrel: Proof.context -> class list -> Pretty.T
val unparse_sort: Proof.context -> sort -> Pretty.T
val unparse_term: Proof.context -> term -> Pretty.T
val unparse_typ: Proof.context -> typ -> Pretty.T
val update_const_gram:
bool ->
string list ->
mode -> (string * typ * mixfix) list -> syntax -> syntax
val update_trfuns:
(string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp)) list *
(string * ((Proof.context -> term list -> term) * stamp)) list *
(string * ((Proof.context -> typ -> term list -> term) * stamp)) list
* (string * ((Proof.context -> Ast.ast list -> Ast.ast) * stamp)) list
-> syntax -> syntax
val update_trrules: Ast.ast trrule list -> syntax -> syntax
val update_type_gram:
bool -> mode -> (string * typ * mixfix) list -> syntax -> syntax
val var: indexname -> term
end
structure Syntax: SYNTAX
val it = (): unit
val it = (): unit
signature BASIC_TERM_ORD =
sig
structure Sorttab: TABLE
structure Termtab: TABLE
structure Typtab: TABLE
structure Vartab: TABLE
end
signature TERM_ORD =
sig
structure Sorttab: TABLE
structure Termtab: TABLE
structure Typtab: TABLE
structure Vartab: TABLE
val fast_indexname_ord: indexname * indexname -> order
val fast_term_ord: term * term -> order
val hd_ord: term * term -> order
val indexname_ord: indexname * indexname -> order
val sort_ord: sort * sort -> order
val syntax_term_ord: term * term -> order
val term_cache: (term -> 'a) -> term -> 'a
val term_lpo: (term -> int) -> term * term -> order
val term_ord: term * term -> order
val termless: term * term -> bool
val tvar_ord: (indexname * sort) * (indexname * sort) -> order
val typ_ord: typ * typ -> order
val var_ord: (indexname * typ) * (indexname * typ) -> order
end
Warning: Matches are not exhaustive.
fun
dest_hd (Const (...)) = (((...), ...), 0) |
dest_hd (... ...) = ((...), ...) |
dest_hd ... = (...) |
dest_hd ... = ... |
...
At (line 140 of "term_ord.ML")
Warning: Matches are not exhaustive.
fun
unrecognized (Const (...)) = ((1, ...), 0) |
unrecognized (... ...) = ((...), ...) |
unrecognized ... = (...) |
unrecognized ... = ... |
...
At (line 188 of "term_ord.ML")
structure Term_Ord: TERM_ORD
structure Basic_Term_Ord: BASIC_TERM_ORD
structure Typtab: TABLE
structure Sorttab: TABLE
structure Vartab: TABLE
structure Termtab: TABLE
structure Var_Graph: GRAPH
structure Sort_Graph: GRAPH
structure Typ_Graph: GRAPH
structure Term_Graph: GRAPH
val it = (): unit
signature TERM_SUBST =
sig
val generalize: string list * string list -> int -> term -> term
val generalizeT: string list -> int -> typ -> typ
val generalizeT_same: string list -> int -> typ Same.operation
val generalize_same:
string list * string list -> int -> term Same.operation
val instantiate:
((indexname * sort) * typ) list * ((indexname * typ) * term) list ->
term -> term
val instantiateT: ((indexname * sort) * typ) list -> typ -> typ
val instantiateT_maxidx:
((indexname * sort) * (typ * int)) list -> typ -> int -> typ * int
val instantiateT_same:
((indexname * sort) * typ) list -> typ Same.operation
val instantiate_maxidx:
((indexname * sort) * (typ * int)) list *
((indexname * typ) * (term * int)) list -> term -> int -> term * int
val instantiate_same:
((indexname * sort) * typ) list * ((indexname * typ) * term) list ->
term Same.operation
val map_aterms_same: term Same.operation -> term Same.operation
val map_atypsT_same: typ Same.operation -> typ Same.operation
val map_types_same: typ Same.operation -> term Same.operation
val zero_var_indexes: term -> term
val zero_var_indexes_inst:
term list ->
((indexname * sort) * typ) list * ((indexname * typ) * term) list
end
structure Term_Subst: TERM_SUBST
val it = (): unit
signature TERM_XML_OPS =
sig type 'a T val sort: sort T val term: term T val typ: typ T end
signature TERM_XML =
sig structure Decode: TERM_XML_OPS structure Encode: TERM_XML_OPS end
Warning: Matches are not exhaustive.
fn Type (a, b) => ([a], ... ... b)
At (line 32 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn TFree (a, b) => ([a], sort b)
At (line 33 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn TVar ((a, ...), c) => ([a, ... ...], sort c)
At (line 34 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn Const (a, b) => ([a], typ b)
At (line 37 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn Free (a, b) => ([a], typ b)
At (line 38 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn Var ((a, ...), c) => ([a, ... ...], typ c)
At (line 39 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn Bound a => ([int_atom a], [])
At (line 40 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn Abs (a, b, ...) => ([a], ... ... (...))
At (line 41 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn $ a => ([], ... ... a)
At (line 42 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => Type (a, ... ...)
At (line 54 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => TFree (a, ... ...)
At (line 55 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a, b], c) => TVar ((a, ...), ... ...)
At (line 56 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => Const (a, ... ...)
At (line 59 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => Free (a, ... ...)
At (line 60 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a, b], c) => Var ((a, ...), ... ...)
At (line 61 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], []) => Bound (int_atom a)
At (line 62 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in Abs (a, ...) end
At (line 63 of "term_xml.ML")
Warning: Matches are not exhaustive.
fn ([], a) => $ (... ... term a)
At (line 64 of "term_xml.ML")
structure Term_XML: TERM_XML
val it = (): unit
signature COMPLETION =
sig
type T
val encode: T -> XML.body
val make:
string * Position.T ->
((string -> bool) -> (string * (string * string)) list) -> T
val names: Position.T -> (string * (string * string)) list -> T
val none: T
val reported_text: T -> string
val suppress_abbrevs: string -> Markup.T list
end
structure Completion: COMPLETION
val it = (): unit
eqtype xstring
signature NAME_SPACE =
sig
type T
val add_path: string -> naming -> naming
val alias: naming -> binding -> string -> T -> T
val alias_table: naming -> binding -> string -> 'a table -> 'a table
val base_name: binding -> string
val change_base: bool -> 'a table -> 'a table
val change_ignore: 'a table -> 'a table
val check:
Context.generic -> 'a table -> xstring * Position.T -> string * 'a
val check_reports:
Context.generic ->
'a table ->
xstring * Position.T list -> (string * Position.report list) * 'a
val completion:
Context.generic -> T -> xstring * Position.T -> Completion.T
val concealed: naming -> naming
val declare: Context.generic -> bool -> binding -> T -> string * T
val define:
Context.generic ->
bool -> binding * 'a -> 'a table -> string * 'a table
val defined: 'a table -> string -> bool
val del_table: string -> 'a table -> 'a table
val empty: string -> T
val empty_table: string -> 'a table
val entry_ord: T -> string * string -> order
val extern: Proof.context -> T -> string -> xstring
val extern_entries:
bool ->
Proof.context ->
T -> (string * 'a) list -> ((string * xstring) * 'a) list
val extern_ord: Proof.context -> T -> string * string -> order
val extern_shortest: Proof.context -> T -> string -> xstring
val extern_table:
bool -> Proof.context -> 'a table -> ((string * xstring) * 'a) list
val fold_table: (string * 'a -> 'b -> 'b) -> 'a table -> 'b -> 'b
val full_name: naming -> binding -> string
val get: 'a table -> string -> 'a
val get_group: naming -> serial option
val get_scope: naming -> Binding.scope option
val get_scopes: naming -> Binding.scope list
val global_naming: naming
val hide: bool -> string -> T -> T
val hide_table: bool -> string -> 'a table -> 'a table
val intern: T -> xstring -> string
val is_concealed: T -> string -> bool
val join_tables:
(string -> 'a * 'a -> 'a) -> 'a table * 'a table -> 'a table
val kind_of: T -> string
val local_naming: naming
val lookup: 'a table -> string -> 'a option
val lookup_key: 'a table -> string -> (string * 'a) option
val mandatory_path: string -> naming -> naming
val map_naming: (naming -> naming) -> Context.generic -> Context.generic
val map_table_entry: string -> ('a -> 'a) -> 'a table -> 'a table
val markup: T -> string -> Markup.T
val markup_def: T -> string -> Markup.T
val markup_entries:
bool ->
Proof.context ->
T -> (string * 'a) list -> ((Markup.T * xstring) * 'a) list
val markup_extern: Proof.context -> T -> string -> Markup.T * xstring
val markup_table:
bool -> Proof.context -> 'a table -> ((Markup.T * xstring) * 'a) list
val merge: T * T -> T
val merge_tables: 'a table * 'a table -> 'a table
val names_long: bool Config.T
val names_long_raw: Config.raw
val names_short: bool Config.T
val names_short_raw: Config.raw
val names_unique: bool Config.T
val names_unique_raw: Config.raw
type naming
val naming_of: Context.generic -> naming
val new_group: naming -> naming
val new_scope: naming -> Binding.scope * naming
val parent_path: naming -> naming
val pretty: Proof.context -> T -> string -> Pretty.T
val private: Position.T -> naming -> naming
val private_scope: Binding.scope -> naming -> naming
val qualified: Position.T -> naming -> naming
val qualified_path: bool -> binding -> naming -> naming
val qualified_scope: Binding.scope -> naming -> naming
val reset_group: naming -> naming
val restricted: bool -> Position.T -> naming -> naming
val root_path: naming -> naming
val set_group: serial option -> naming -> naming
val set_theory_name: string -> naming -> naming
val space_of_table: 'a table -> T
type 'a table
val the_entry:
T ->
string ->
{concealed: bool,
group: serial option,
pos: Position.T, serial: serial, theory_name: string}
val transform_binding: naming -> binding -> binding
val transform_naming: naming -> naming -> naming
end
structure Name_Space: NAME_SPACE
val it = (): unit
signature SORTS =
sig
exception CLASS_ERROR of class_error
val add_arities:
Context.generic ->
string * (class * sort list) list -> algebra -> algebra
val add_class:
Context.generic -> class * class list -> algebra -> algebra
val add_classrel: Context.generic -> class * class -> algebra -> algebra
type algebra
val all_classes: algebra -> class list
val arities_of: algebra -> (class * sort list) list Symtab.table
val class_error: Context.generic -> class_error -> string
type class_error
val class_le: algebra -> class * class -> bool
val class_less: algebra -> class * class -> bool
val classes_of: algebra -> serial Graph.T
val classrel_derivation:
algebra -> ('a * class -> class -> 'a) -> 'a * class -> class -> 'a
val complete_sort: algebra -> sort -> sort
val empty_algebra: algebra
val has_instance: algebra -> string -> sort -> bool
val insert_sort: sort -> sort list -> sort list
val insert_term: term -> sort list -> sort list
val insert_terms: term list -> sort list -> sort list
val insert_typ: typ -> sort list -> sort list
val insert_typs: typ list -> sort list -> sort list
val inter_sort: algebra -> sort * sort -> sort
val make: sort list -> sort list
val meet_sort:
algebra -> typ * sort -> sort Vartab.table -> sort Vartab.table
val meet_sort_typ: algebra -> typ * sort -> typ -> typ
val merge_algebra: Context.generic -> algebra * algebra -> algebra
val mg_domain: algebra -> string -> sort -> sort list
val minimal_sorts: algebra -> sort list -> sort list
val minimize_sort: algebra -> sort -> sort
val of_sort: algebra -> typ * sort -> bool
val of_sort_derivation:
algebra ->
{class_relation: typ -> bool -> 'a * class -> class -> 'a,
type_constructor:
string * typ list -> ('a * class) list list -> class -> 'a,
type_variable: typ -> ('a * class) list} -> typ * sort -> 'a list
val remove_sort: sort -> sort list -> sort list
val sort_eq: algebra -> sort * sort -> bool
val sort_le: algebra -> sort * sort -> bool
val sorts_le: algebra -> sort list * sort list -> bool
val subalgebra:
Context.generic ->
(class -> bool) ->
(class * string -> sort list option) ->
algebra -> (sort -> sort) * algebra
val subset: sort list * sort list -> bool
val subtract: sort list -> sort list -> sort list
val super_classes: algebra -> class -> class list
val union: sort list -> sort list -> sort list
val witness_sorts:
algebra ->
string list -> (typ * sort) list -> sort list -> (typ * sort) list
end
structure Sorts: SORTS
val it = (): unit
signature TYPE =
sig
exception TUNIFY
exception TYPE_MATCH
val add_abbrev:
Context.generic -> binding * string list * typ -> tsig -> tsig
val add_arity: Context.generic -> arity -> tsig -> tsig
val add_class: Context.generic -> binding * class list -> tsig -> tsig
val add_classrel: Context.generic -> class * class -> tsig -> tsig
val add_nonterminal: Context.generic -> binding -> tsig -> tsig
val add_type: Context.generic -> binding * int -> tsig -> tsig
val appl_error: Proof.context -> term -> typ -> term -> typ -> string
val arity_number: tsig -> string -> int
val arity_sorts: Context.generic -> tsig -> string -> sort -> sort list
val cert_class: tsig -> class -> class
val cert_sort: tsig -> sort -> sort
val cert_typ: tsig -> typ -> typ
val cert_typ_mode: mode -> tsig -> typ -> typ
val change_base: bool -> tsig -> tsig
val change_ignore: tsig -> tsig
val check_decl:
Context.generic ->
tsig ->
xstring * Position.T -> (string * Position.report list) * decl
val class_space: tsig -> Name_Space.T
val constraint: typ -> term -> term
val constraint_type: Proof.context -> typ -> typ
val could_match: typ * typ -> bool
val could_matches: typ list * typ list -> bool
val could_unify: typ * typ -> bool
val could_unifys: typ list * typ list -> bool
datatype decl =
Abbreviation of string list * typ * bool
| LogicalType of int
| Nonterminal
val defaultS: tsig -> sort
val devar: tyenv -> typ -> typ
val empty_tsig: tsig
val eq_sort: tsig -> sort * sort -> bool
val eq_tsig: tsig * tsig -> bool
val get_mode: Proof.context -> mode
val hide_class: bool -> string -> tsig -> tsig
val hide_type: bool -> string -> tsig -> tsig
val inter_sort: tsig -> sort * sort -> sort
val legacy_freeze: term -> term
val legacy_freeze_thaw: term -> term * (term -> term)
val legacy_freeze_thaw_type: typ -> typ * (typ -> typ)
val legacy_freeze_type: typ -> typ
val logical_types: tsig -> string list
val lookup: tyenv -> indexname * sort -> typ option
val mark_polymorphic: typ -> typ
val merge_tsig: Context.generic -> tsig * tsig -> tsig
val minimize_sort: tsig -> sort -> sort
type mode
val mode_abbrev: mode
val mode_default: mode
val mode_syntax: mode
val no_tvars: typ -> typ
val of_sort: tsig -> typ * sort -> bool
val raw_instance: typ * typ -> bool
val raw_match: typ * typ -> tyenv -> tyenv
val raw_matches: typ list * typ list -> tyenv -> tyenv
val raw_unify: typ * typ -> tyenv -> tyenv
val raw_unifys: typ list * typ list -> tyenv -> tyenv
val rep_tsig:
tsig ->
{classes: Name_Space.T * Sorts.algebra,
default: sort,
log_types: string list, types: decl Name_Space.table}
val restore_mode: Proof.context -> Proof.context -> Proof.context
val set_defsort: sort -> tsig -> tsig
val set_mode: mode -> Proof.context -> Proof.context
val sort_of_atyp: typ -> sort
val strip_constraints: term -> term
val strip_sorts: typ -> typ
val strip_sorts_dummy: typ -> typ
val subsort: tsig -> sort * sort -> bool
val the_decl: tsig -> string * Position.T -> decl
type tsig
type tyenv = (sort * typ) Vartab.table
val typ_instance: tsig -> typ * typ -> bool
val typ_match: tsig -> typ * typ -> tyenv -> tyenv
val type_alias: Name_Space.naming -> binding -> string -> tsig -> tsig
val type_space: tsig -> Name_Space.T
val unified: tyenv -> typ * typ -> bool
val unify: tsig -> typ * typ -> tyenv * int -> tyenv * int
val varify_global:
(string * sort) list ->
term -> ((string * sort) * indexname) list * term
val witness_sorts:
tsig -> (typ * sort) list -> sort list -> (typ * sort) list
end
Warning: Matches are not exhaustive.
fn TFree (x, _) => TFree (x, [...]) | TVar (xi, ...) => TVar (xi, ...)
At (line 338 of "type.ML")
Warning: Matches are not exhaustive.
fn TFree (x, _) => TFree (x, dummyS) | TVar (xi, ...) => TVar (xi, ...)
At (line 342 of "type.ML")
Warning: Value identifier (T) has not been referenced.
At (line 591 of "type.ML")
structure Type: TYPE
val it = (): unit
signature LOGIC =
sig
val all: term -> term -> term
val all_const: typ -> term
val all_constraint:
(string -> typ option) -> string * string -> term -> term
val assum_pairs: int * term -> (term * term) list
val assum_problems: int * term -> (term -> term) * term list * term
val class_of_const: string -> class
val close_form: term -> term
val close_prop: (string * term) list -> term list -> term -> term
val close_prop_constraint:
(string -> typ option) ->
(string * string) list -> term list -> term -> term
val close_term: (string * term) list -> term -> term
val combound: term * int * int -> term
val concl_of_goal: term -> int -> term
val conjunction: term
val const_of_class: class -> string
val count_prems: term -> int
val dependent_all_constraint:
(string -> typ option) -> string * string -> term -> term
val dependent_all_name: string * term -> term -> term
val dest_all: term -> (string * typ) * term
val dest_arity: term -> string * sort list * class
val dest_classrel: term -> class * class
val dest_conjunction: term -> term * term
val dest_conjunction_balanced: int -> term -> term list
val dest_conjunction_list: term -> term list
val dest_conjunctions: term -> term list
val dest_equals: term -> term * term
val dest_implies: term -> term * term
val dest_of_class: term -> typ * class
val dest_term: term -> term
val dest_type: term -> typ
val flatten_params: int -> term -> term
val get_goal: term -> int -> term
val goal_params: term -> int -> term * term list
val has_meta_prems: term -> bool
val implies: term
val incr_indexes: string list * typ list * int -> term -> term
val incr_indexes_same:
string list * typ list * int -> term Same.operation
val incr_tvar: int -> typ -> typ
val incr_tvar_same: int -> typ Same.operation
val is_all: term -> bool
val lift_abs: int -> term -> term -> term
val lift_all: int -> term -> term -> term
val list_all: (string * typ) list * term -> term
val list_implies: term list * term -> term
val list_rename_params: string list -> term -> term
val mk_arities: arity -> term list
val mk_classrel: class * class -> term
val mk_conjunction: term * term -> term
val mk_conjunction_balanced: term list -> term
val mk_conjunction_list: term list -> term
val mk_equals: term * term -> term
val mk_implies: term * term -> term
val mk_of_class: typ * class -> term
val mk_of_sort: typ * sort -> term list
val mk_term: term -> term
val mk_type: typ -> term
val name_arities: arity -> string list
val name_arity: string * sort list * class -> string
val name_classrel: string * string -> string
val nth_prem: int * term -> term
val occs: term * term -> bool
val prems_of_goal: term -> int -> term list
val protect: term -> term
val protectC: term
val rlist_abs: (string * typ) list * term -> term
val strip_assums_concl: term -> term
val strip_assums_hyp: term -> term list
val strip_horn: term -> term list * term
val strip_imp_concl: term -> term
val strip_imp_prems: term -> term list
val strip_params: term -> (string * typ) list
val strip_prems: int * term list * term -> term list * term
val true_prop: term
val type_map: (term -> term) -> typ -> typ
val unconstrainT:
sort list ->
term ->
((typ -> typ) * ((typ * class) * term) list * (typ * class) list)
* term
val unprotect: term -> term
val unvarifyT_global: typ -> typ
val unvarify_global: term -> term
val unvarify_types_global: term -> term
val varifyT_global: typ -> typ
val varify_global: term -> term
val varify_types_global: term -> term
end
Warning: Value identifier (A) has not been referenced.
At (line 185 of "logic.ML")
Warning: Matches are not exhaustive.
fn (_, T as ... ...) => map (fn ... => ...) S
At (line 360 of "logic.ML")
Warning: Value identifier (B) has not been referenced.
At (line 471 of "logic.ML")
Warning: Value identifier (T) has not been referenced.
At (line 469 of "logic.ML")
Warning: Value identifier (a) has not been referenced.
At (line 469 of "logic.ML")
Warning: Value identifier (T) has not been referenced.
At (line 476 of "logic.ML")
Warning: Value identifier (a) has not been referenced.
At (line 476 of "logic.ML")
Warning: Value identifier (H) has not been referenced.
At (line 475 of "logic.ML")
Warning: Value identifier (B) has not been referenced.
At (line 482 of "logic.ML")
Warning: Value identifier (H) has not been referenced.
At (line 480 of "logic.ML")
Warning: Value identifier (T) has not been referenced.
At (line 505 of "logic.ML")
Warning: Value identifier (a) has not been referenced.
At (line 505 of "logic.ML")
Warning: Value identifier (cs) has not been referenced.
At (line 522 of "logic.ML")
Warning: Matches are not exhaustive.
fn TFree (a, S) => TVar ((a, ...), S) | TVar (ai, ...) => raise TYPE (...)
At (line 577 of "logic.ML")
Warning: Matches are not exhaustive.
fn
TVar ((a, ...), S) => TFree (a, S) |
TVar (ai, ...) => raise TYPE (...) |
TFree (...) => raise ... ...
At (line 582 of "logic.ML")
structure Logic: LOGIC
val it = (): unit
signature SIMPLE_SYNTAX =
sig
val read_prop: string -> term
val read_term: string -> term
val read_typ: string -> typ
end
structure Simple_Syntax: SIMPLE_SYNTAX
val it = (): unit
signature NET =
sig
exception DELETE
exception INSERT
val content: 'a net -> 'a list
val delete: ('a * 'b -> bool) -> key list * 'a -> 'b net -> 'b net
val delete_safe: ('a * 'b -> bool) -> key list * 'a -> 'b net -> 'b net
val delete_term: ('a * 'b -> bool) -> term * 'a -> 'b net -> 'b net
val delete_term_safe: ('a * 'b -> bool) -> term * 'a -> 'b net -> 'b net
val empty: 'a net
val encode_type: typ -> term
val entries: 'a net -> 'a list
val insert: ('a * 'a -> bool) -> key list * 'a -> 'a net -> 'a net
val insert_safe: ('a * 'a -> bool) -> key list * 'a -> 'a net -> 'a net
val insert_term: ('a * 'a -> bool) -> term * 'a -> 'a net -> 'a net
val insert_term_safe: ('a * 'a -> bool) -> term * 'a -> 'a net -> 'a net
val is_empty: 'a net -> bool
type key
val key_of_term: term -> key list
val lookup: 'a net -> key list -> 'a list
val match_term: 'a net -> term -> 'a list
val merge: ('a * 'a -> bool) -> 'a net * 'a net -> 'a net
type 'a net
val subtract: ('a * 'b -> bool) -> 'b net -> 'a net -> 'a list
val unify_term: 'a net -> term -> 'a list
end
Warning: Matches are not exhaustive.
fun
rands (... $ ..., ...) = CombK :: rands (...) |
rands (...) = ... ... :: cs |
rands ... = ... :: ... |
rands ... = ...
At (line 54 of "net.ML")
Warning: Matches are not exhaustive.
fun
ins1 ([...], ...) = if ... ... x then raise INSERT else Leaf (... :: ...)
|
ins1 (...) = ins1 (...) |
ins1 ... = ... ... |
ins1 ... = ... |
...
At (line 99 of "net.ML")
Warning: Value identifier (keys) has not been referenced.
At (line 133 of "net.ML")
Warning: Matches are not exhaustive.
fun
del1 ([...], ...) = if ... ... x then Leaf (... ...) else raise DELETE |
del1 (...) = raise DELETE |
del1 ... = ... ... |
del1 ... = ... |
...
At (line 130 of "net.ML")
Warning: Matches are not exhaustive.
fun
lookup (Leaf xs) [...] = xs |
lookup (... ...) ... = [] |
lookup ... = ... ... |
lookup ... = ... |
...
At (line 158 of "net.ML")
Warning: Matches are not exhaustive.
fn Leaf xs => xs
At (line 211 of "net.ML")
structure Net: NET
val it = (): unit
signature ITEM_NET =
sig
type 'a T
val content: 'a T -> 'a list
val filter: ('a -> bool) -> 'a T -> 'a T
val init: ('a * 'a -> bool) -> ('a -> term list) -> 'a T
val length: 'a T -> int
val lookup: 'a T -> 'a -> 'a list
val member: 'a T -> 'a -> bool
val merge: 'a T * 'a T -> 'a T
val remove: 'a -> 'a T -> 'a T
val retrieve: 'a T -> term -> 'a list
val retrieve_matching: 'a T -> term -> 'a list
val update: 'a -> 'a T -> 'a T
end
structure Item_Net: ITEM_NET
val it = (): unit
signature ENVIR =
sig
val above: env -> int -> bool
val aeconv: term * term -> bool
val beta_eta_contract: term -> term
val beta_norm: term -> term
val binder_types: env -> typ -> typ list
val body_type: env -> typ -> typ
val empty: int -> env
datatype env = Envir of {maxidx: int, tenv: tenv, tyenv: Type.tyenv}
val eta_contract: term -> term
val eta_long: typ list -> term -> term
val expand_atom: typ -> typ * term -> term
val expand_term: (term -> (typ * term) option) -> term -> term
val expand_term_frees: ((string * typ) * term) list -> term -> term
val fastype: env -> typ list -> term -> typ
val genvar: string -> env * typ -> env * term
val genvars: string -> env * typ list -> env * term list
val head_norm: env -> term -> term
val init: env
val insert_sorts: env -> sort list -> sort list
val is_empty: env -> bool
val lookup: env -> indexname * typ -> term option
val lookup1: tenv -> indexname * typ -> term option
val maxidx_of: env -> int
val merge: env * env -> env
val norm_term: env -> term -> term
val norm_term_same: env -> term Same.operation
val norm_type: Type.tyenv -> typ -> typ
val norm_type_same: Type.tyenv -> typ Same.operation
val norm_types_same: Type.tyenv -> typ list Same.operation
val strip_type: env -> typ -> typ list * typ
val subst_term: Type.tyenv * tenv -> term -> term
val subst_term_same: Type.tyenv * tenv -> term Same.operation
val subst_term_types: Type.tyenv -> term -> term
val subst_term_types_same: Type.tyenv -> term Same.operation
val subst_type: Type.tyenv -> typ -> typ
val subst_type_same: Type.tyenv -> typ Same.operation
type tenv = (typ * term) Vartab.table
val term_env: env -> tenv
val type_env: env -> Type.tyenv
val update: (indexname * typ) * term -> env -> env
val vupdate: (indexname * typ) * term -> env -> env
end
Warning: Pattern is not exhaustive.
val (env', [v]) = genvars name (env, [...])
At (line 112 of "envir.ML")
structure Envir: ENVIR
val it = (): unit
signature CONSTS =
sig
type T
val abbreviate:
Context.generic ->
Type.tsig -> string -> binding * term -> T -> (term * term) * T
val alias: Name_Space.naming -> binding -> string -> T -> T
val certify: Context.generic -> Type.tsig -> bool -> T -> term -> term
val change_base: bool -> T -> T
val change_ignore: T -> T
val check_const:
Context.generic ->
T -> xstring * Position.T list -> term * Position.report list
val constrain: string * typ option -> T -> T
val declare: Context.generic -> binding * typ -> T -> T
val dest:
T ->
{const_space: Name_Space.T,
constants: (string * (typ * term option)) list,
constraints: (string * typ) list}
val empty: T
val eq_consts: T * T -> bool
val hide: bool -> string -> T -> T
val instance: T -> string * typ list -> typ
val intern: T -> xstring -> string
val intern_syntax: T -> xstring -> string
val is_concealed: T -> string -> bool
val is_monomorphic: T -> string -> bool
val merge: T * T -> T
val retrieve_abbrevs: T -> string list -> term -> (term * term) list
val revert_abbrev: string -> string -> T -> T
val space_of: T -> Name_Space.T
val the_abbreviation: T -> string -> typ * term
val the_const: T -> string -> string * typ
val the_constraint: T -> string -> typ
val typargs: T -> string * typ -> typ list
val type_scheme: T -> string -> typ
end
structure Consts: CONSTS
val it = (): unit
signature PRIMITIVE_DEFS =
sig
val abs_def: term -> term * term
val dest_def:
Proof.context ->
{check_free_lhs: string -> bool,
check_free_rhs: string -> bool,
check_head: term -> bool, check_tfree: string -> bool} ->
term -> (term * term) * term list * term
end
structure Primitive_Defs: PRIMITIVE_DEFS
val it = (): unit
signature SIGN =
sig
val add_abbrev:
string -> binding * term -> theory -> (term * term) * theory
val add_const_constraint: string * typ option -> theory -> theory
val add_consts: (binding * typ * mixfix) list -> theory -> theory
val add_consts_cmd: (binding * string * mixfix) list -> theory -> theory
val add_nonterminals: Proof.context -> binding list -> theory -> theory
val add_nonterminals_global: binding list -> theory -> theory
val add_path: string -> theory -> theory
val add_syntax:
Syntax.mode -> (string * typ * mixfix) list -> theory -> theory
val add_syntax_cmd:
Syntax.mode -> (string * string * mixfix) list -> theory -> theory
val add_trrules: Ast.ast Syntax.trrule list -> theory -> theory
val add_type: Proof.context -> binding * int * mixfix -> theory -> theory
val add_type_abbrev:
Proof.context -> binding * string list * typ -> theory -> theory
val add_types_global: (binding * int * mixfix) list -> theory -> theory
val all_classes: theory -> class list
val arity_number: theory -> string -> int
val arity_sorts: theory -> string -> sort -> sort list
val cert_prop: theory -> term -> term
val cert_term: theory -> term -> term
val certify':
bool ->
Context.generic ->
bool -> Consts.T -> theory -> term -> term * typ * int
val certify_class: theory -> class -> class
val certify_sort: theory -> sort -> sort
val certify_term: theory -> term -> term * typ * int
val certify_typ: theory -> typ -> typ
val certify_typ_mode: Type.mode -> theory -> typ -> typ
val change_begin: theory -> theory
val change_check: theory -> theory
val change_end: theory -> theory
val change_end_local: Proof.context -> Proof.context
val class_space: theory -> Name_Space.T
val classes_of: theory -> Sorts.algebra
val complete_sort: theory -> sort -> sort
val concealed: theory -> theory
val const_alias: binding -> string -> theory -> theory
val const_instance: theory -> string * typ list -> typ
val const_monomorphic: theory -> string -> bool
val const_space: theory -> Name_Space.T
val const_typargs: theory -> string * typ -> typ list
val const_type: theory -> string -> typ option
val consts_of: theory -> Consts.T
val declare_const:
Proof.context -> (binding * typ) * mixfix -> theory -> term * theory
val declare_const_global:
(binding * typ) * mixfix -> theory -> term * theory
val declared_const: theory -> string -> bool
val declared_tyname: theory -> string -> bool
val defaultS: theory -> sort
val del_syntax:
Syntax.mode -> (string * typ * mixfix) list -> theory -> theory
val del_syntax_cmd:
Syntax.mode -> (string * string * mixfix) list -> theory -> theory
val del_trrules: Ast.ast Syntax.trrule list -> theory -> theory
val full_bname: theory -> bstring -> string
val full_bname_path: theory -> string -> bstring -> string
val full_name: theory -> binding -> string
val full_name_path: theory -> string -> binding -> string
val get_scope: theory -> Binding.scope option
val hide_class: bool -> string -> theory -> theory
val hide_const: bool -> string -> theory -> theory
val hide_type: bool -> string -> theory -> theory
val inherit_naming: theory -> Proof.context -> Context.generic
val inter_sort: theory -> sort * sort -> sort
val intern_class: theory -> xstring -> string
val intern_const: theory -> xstring -> string
val intern_type: theory -> xstring -> string
val local_path: theory -> theory
val logical_types: theory -> string list
val mandatory_path: string -> theory -> theory
val map_naming:
(Name_Space.naming -> Name_Space.naming) -> theory -> theory
val minimize_sort: theory -> sort -> sort
val mk_const: theory -> string * typ list -> term
val naming_of: theory -> Name_Space.naming
val new_group: theory -> theory
val new_scope: theory -> Binding.scope * theory
val no_frees: Proof.context -> term -> term
val no_vars: Proof.context -> term -> term
val notation:
bool -> Syntax.mode -> (term * mixfix) list -> theory -> theory
val of_sort: theory -> typ * sort -> bool
val parent_path: theory -> theory
val parse_ast_translation:
(string * (Proof.context -> Ast.ast list -> Ast.ast)) list ->
theory -> theory
val parse_translation:
(string * (Proof.context -> term list -> term)) list ->
theory -> theory
val primitive_arity: arity -> theory -> theory
val primitive_class: binding * class list -> theory -> theory
val primitive_classrel: class * class -> theory -> theory
val print_ast_translation:
(string * (Proof.context -> Ast.ast list -> Ast.ast)) list ->
theory -> theory
val print_translation:
(string * (Proof.context -> term list -> term)) list ->
theory -> theory
val private: Position.T -> theory -> theory
val private_scope: Binding.scope -> theory -> theory
val qualified: Position.T -> theory -> theory
val qualified_path: bool -> binding -> theory -> theory
val qualified_scope: Binding.scope -> theory -> theory
val reset_group: theory -> theory
val restore_naming: theory -> theory -> theory
val revert_abbrev: string -> string -> theory -> theory
val root_path: theory -> theory
val set_defsort: sort -> theory -> theory
val subsort: theory -> sort * sort -> bool
val super_classes: theory -> class -> class list
val syn_of: theory -> Syntax.syntax
val the_const_constraint: theory -> string -> typ
val the_const_type: theory -> string -> typ
val tsig_of: theory -> Type.tsig
val typ_equiv: theory -> typ * typ -> bool
val typ_instance: theory -> typ * typ -> bool
val typ_match: theory -> typ * typ -> Type.tyenv -> Type.tyenv
val typ_unify:
theory -> typ * typ -> Type.tyenv * int -> Type.tyenv * int
val type_alias: binding -> string -> theory -> theory
val type_notation:
bool -> Syntax.mode -> (typ * mixfix) list -> theory -> theory
val type_space: theory -> Name_Space.T
val typed_print_translation:
(string * (Proof.context -> typ -> term list -> term)) list ->
theory -> theory
val witness_sorts:
theory -> (typ * sort) list -> sort list -> (typ * sort) list
end
structure Sign: SIGN
val it = (): unit
signature DEFS =
sig
type T
val all_specifications_of: T -> (item * spec list) list
type context = Proof.context * (Name_Space.T * Name_Space.T)
val define:
context ->
bool -> string option -> string -> entry -> entry list -> T -> T
val dest:
T ->
{reducts: (entry * entry list) list,
restricts: (entry * string) list}
val empty: T
type entry = item * typ list
val get_deps: T -> item -> (typ list * entry list) list
val global_context: theory -> context
type item = item_kind * string
datatype item_kind = Const | Type
val item_kind_ord: item_kind * item_kind -> order
val merge: context -> T * T -> T
val plain_args: typ list -> bool
val pretty_args: Proof.context -> typ list -> Pretty.T list
val pretty_entry: context -> entry -> Pretty.T
val pretty_item: context -> item -> Pretty.T
val space: context -> item_kind -> Name_Space.T
type spec =
{def: string option,
description: string, lhs: typ list, pos: Position.T, rhs: entry list}
val specifications_of: T -> item -> spec list
end
structure Defs: DEFS
val it = (): unit
signature TERM_SHARING =
sig
val init: theory -> (typ -> typ) * (term -> term)
val terms: theory -> term list -> term list
val typs: theory -> typ list -> typ list
end
structure Term_Sharing: TERM_SHARING
val it = (): unit
signature PATTERN =
sig
exception MATCH
exception Pattern
exception Unif
val first_order_match:
theory ->
term * term -> Type.tyenv * Envir.tenv -> Type.tyenv * Envir.tenv
val match:
theory ->
term * term -> Type.tyenv * Envir.tenv -> Type.tyenv * Envir.tenv
val unify: Context.generic -> term * term -> Envir.env -> Envir.env
val unify_trace_failure: bool Config.T
val unify_trace_failure_raw: Config.raw
val unify_types: Context.generic -> typ * typ -> Envir.env -> Envir.env
end
Warning: Value identifier (j) has not been referenced.
At (line 108 of "pattern.ML")
Warning: Matches are not exhaustive.
case (strip_comb s, strip_comb t) of
((Var (...), ss), (... ..., ...)) =>
if F = G then flexflex1 (env, ...) else flexflex2 (env, ...) |
((... ..., ...), _) => flexrigid context (env, ...) |
(_, ...) => ... ... (...) |
(...) => ... ... |
... => ... |
...
At (line 245 of "pattern.ML")
Warning: Value identifier (U) has not been referenced.
At (line 315 of "pattern.ML")
Warning: Value identifier (itms) has not been referenced.
At (line 336 of "pattern.ML")
structure Pattern: PATTERN
val it = (): unit
Warning: Value identifier (occurs) has not been referenced.
At (line 148 of "unify.ML")
Warning: Pattern is not exhaustive.
val (Var (vT as (...)), targs) = strip_comb t
At (line 401 of "unify.ML")
Warning: Value identifier (lev) has not been referenced.
At (line 468 of "unify.ML")
Warning: Pattern is not exhaustive.
val (Var (v, ...), ts) = strip_comb t
At (line 501 of "unify.ML")
Warning: Value identifier (w) has not been referenced.
At (line 648 of "unify.ML")
signature UNIFY =
sig
val hounifiers:
Context.generic * Envir.env * (term * term) list ->
(Envir.env * (term * term) list) Seq.seq
val search_bound: int Config.T
val search_bound_raw: Config.raw
val smash_unifiers:
Context.generic ->
(term * term) list -> Envir.env -> Envir.env Seq.seq
val trace_bound: int Config.T
val trace_bound_raw: Config.raw
val trace_simp: bool Config.T
val trace_simp_raw: Config.raw
val trace_types: bool Config.T
val trace_types_raw: Config.raw
val unifiers:
Context.generic * Envir.env * (term * term) list ->
(Envir.env * (term * term) list) Seq.seq
end
structure Unify: UNIFY
val it = (): unit
Warning: Matches are not exhaustive.
fn TFree v => if ... ... lhs_vars v then I else insert (=) v
At (line 230 of "theory.ML")
Warning: Pattern is not exhaustive.
val (lhs as ((...), ...)) :: rhs = map (cert_entry thy) (raw_lhs :: raw_rhs)
At (line 247 of "theory.ML")
signature THEORY =
sig
val add_axiom: Proof.context -> binding * term -> theory -> theory
val add_def:
Defs.context -> bool -> bool -> binding * term -> theory -> theory
val add_deps:
Defs.context ->
string -> Defs.entry -> Defs.entry list -> theory -> theory
val add_deps_global:
string -> Defs.entry -> Defs.entry list -> theory -> theory
val all_axioms_of: theory -> (string * term) list
val ancestors_of: theory -> theory list
val at_begin: (theory -> theory option) -> theory -> theory
val at_end: (theory -> theory option) -> theory -> theory
val axiom_space: theory -> Name_Space.T
val axiom_table: theory -> term Name_Space.table
val axioms_of: theory -> (string * term) list
val begin_theory: string * Position.T -> theory list -> theory
val check: Proof.context -> string * Position.T -> theory
val check_overloading: Proof.context -> bool -> string * typ -> unit
val const_dep: theory -> string * typ -> Defs.entry
val defs_of: theory -> Defs.T
val end_theory: theory -> theory
val get_markup: theory -> Markup.T
val local_setup: (Proof.context -> Proof.context) -> unit
val nodes_of: theory -> theory list
val parents_of: theory -> theory list
val setup: (theory -> theory) -> unit
val specify_const: (binding * typ) * mixfix -> theory -> term * theory
val type_dep: string * typ list -> Defs.entry
end
structure Theory: THEORY
val it = (): unit
infix 8 %
infix 8 %%
infix 8 %>
signature BASIC_PROOFTERM =
sig
val %>: proof * term -> proof
datatype proof =
% of proof * term option
| %% of proof * proof
| AbsP of string * term option * proof
| Abst of string * typ option * proof
| Hyp of term
| MinProof
| OfClass of typ * class
| Oracle of string * term * typ list option
| PAxm of string * term * typ list option
| PBound of int
| PThm of
serial * ((string * term * typ list option) * proof_body future)
| Promise of serial * term * typ list
datatype proof_body =
PBody of
{oracles: (string * term) list,
proof: proof, thms: (serial * thm_node) list}
type thm_node
end
Warning: Matches are not exhaustive.
fn MinProof => ([], [])
At (line 320 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn PBound a => ([int_atom a], [])
At (line 321 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn Abst (a, b, ...) => ([a], ... ... (...))
At (line 322 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn AbsP (a, b, ...) => ([a], ... ... (...))
At (line 323 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn a % b => ([], ... ... (...))
At (line 324 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn a %% b => ([], ... ... (...))
At (line 325 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn Hyp a => ([], term a)
At (line 326 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn PAxm (a, b, ...) => ([a], ... ... (...))
At (line 327 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn OfClass (a, b) => ([b], typ a)
At (line 328 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn Oracle (a, b, ...) => ([a], ... ... (...))
At (line 329 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn Promise (a, b, ...) => ([int_atom a], ... ... (...))
At (line 330 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn PThm (a, (...)) => ([int_atom a, b], ... ... (...))
At (line 331 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([], []) => MinProof
At (line 354 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], []) => PBound (int_atom a)
At (line 355 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in Abst (a, ...) end
At (line 356 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in AbsP (a, ...) end
At (line 357 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([], a) => % (... ... (... ...) a)
At (line 358 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([], a) => %% (... ... proof a)
At (line 359 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([], a) => Hyp (term a)
At (line 360 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in PAxm (a, ...) end
At (line 361 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([b], a) => OfClass (typ a, b)
At (line 362 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in Oracle (a, ...) end
At (line 363 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a], b) => let val (...) = ... ... in Promise (... ..., ...) end
At (line 364 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn ([a, b], c) => let val (...) = ... ... in PThm (... ..., ...) end
At (line 365 of "proofterm.ML")
Warning: Matches are not exhaustive.
case t of Var ((a, ...), T) => (a, T) | Free p => p
At (line 784 of "proofterm.ML")
Warning: Value identifier (A) has not been referenced.
At (line 909 of "proofterm.ML")
Warning: Value identifier (A) has not been referenced.
At (line 930 of "proofterm.ML")
Warning: Value identifier (T) has not been referenced.
At (line 932 of "proofterm.ML")
Warning: Value identifier (T) has not been referenced.
At (line 945 of "proofterm.ML")
Warning: Value identifier (A) has not been referenced.
At (line 943 of "proofterm.ML")
Warning: Value identifier (U) has not been referenced.
At (line 1015 of "proofterm.ML")
Warning: Matches are not exhaustive.
fun
combination f g ...
=
let val ... = ...; val ...; ... in (case T of ... => ... | ...) end
At (line 1015 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn (v as Var (ixn, ...)) => if ... ... nvs ixn then SOME v else NONE
At (line 1183 of "proofterm.ML")
Warning: Pattern is not exhaustive.
val (is, ch, ... :: ..., ...) = ... ... (... :: ...) prfs prf1
At (line 1217 of "proofterm.ML")
Warning: Value identifier (j) has not been referenced.
At (line 1323 of "proofterm.ML")
Warning: Value identifier (i) has not been referenced.
At (line 1323 of "proofterm.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 1323 of "proofterm.ML")
Warning: Value identifier (j) has not been referenced.
At (line 1320 of "proofterm.ML")
Warning: Value identifier (i) has not been referenced.
At (line 1320 of "proofterm.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 1320 of "proofterm.ML")
Warning: Value identifier (j) has not been referenced.
At (line 1317 of "proofterm.ML")
Warning: Value identifier (i) has not been referenced.
At (line 1317 of "proofterm.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 1317 of "proofterm.ML")
Warning: Value identifier (Ts) has not been referenced.
At (line 1294 of "proofterm.ML")
Warning: Matches are not exhaustive.
fn (v as Var (ixn, ...)) => if ... ... nvs ixn then SOME v else NONE
At (line 1601 of "proofterm.ML")
signature PROOFTERM =
sig
val %>: proof * term -> proof
val abstract_rule: term -> string -> proof -> proof
val abstract_rule_axm: proof
val add_prf_rproc:
(typ list -> term option list -> proof -> (proof * proof) option) ->
theory -> theory
val add_prf_rrule: proof * proof -> theory -> theory
val all_oracles_of: proof_body -> oracle list
val approximate_proof_body: proof -> proof_body
val arity_proof: theory -> string * sort list * class -> proof
val assumption_proof: term list -> term -> int -> proof -> proof
val atomic_proof: proof -> bool
val axm_proof: string -> term -> proof
val bicompose_proof:
bool ->
term list ->
term list ->
term list ->
term option -> int -> int -> proof -> proof -> proof
val change_type: typ list option -> proof -> proof
val classrel_proof: theory -> class * class -> proof
val combination:
term -> term -> term -> term -> typ -> proof -> proof -> proof
val combination_axm: proof
val compact_proof: proof -> bool
val consolidate: proof_body list -> unit
val decode: proof XML.Decode.T
val decode_body: proof_body XML.Decode.T
val encode: proof XML.Encode.T
val encode_body: proof_body XML.Encode.T
val equal_elim: term -> term -> proof -> proof -> proof
val equal_elim_axm: proof
val equal_intr: term -> term -> proof -> proof -> proof
val equal_intr_axm: proof
val equality_axms: (string * term) list
val fold_body_thms:
({body: proof_body, name: string, prop: term, serial: serial} ->
'a -> 'a) -> proof_body list -> 'a -> 'a
val fold_proof_atoms:
bool -> (proof -> 'a -> 'a) -> proof list -> 'a -> 'a
val fold_proof_terms:
(term -> 'a -> 'a) -> (typ -> 'a -> 'a) -> proof -> 'a -> 'a
val forall_intr_proof: term -> string -> proof -> proof
val forall_intr_proof': term -> proof -> proof
val freeze_thaw_prf: proof -> proof * (proof -> proof)
val fulfill_norm_proof:
theory -> (serial * proof_body) list -> proof_body -> proof_body
val generalize: string list * string list -> int -> proof -> proof
val get_name: sort list -> term list -> term -> proof -> string
val guess_name: proof -> string
val implies_intr_proof: term -> proof -> proof
val implies_intr_proof': term -> proof -> proof
val incr_indexes: int -> proof -> proof
val incr_pboundvars: int -> int -> proof -> proof
val install_axclass_proofs:
{arity_proof: theory -> string * sort list * class -> proof,
classrel_proof: theory -> class * class -> proof} ->
theory -> theory
val instantiate:
((indexname * sort) * typ) list * ((indexname * typ) * term) list ->
proof -> proof
val join_proof: proof_body future -> proof
val legacy_freezeT: term -> proof -> proof
val lift_proof: term -> int -> term -> proof -> proof
val map_proof_same:
term Same.operation ->
typ Same.operation -> (typ * class -> proof) -> proof Same.operation
val map_proof_terms: (term -> term) -> (typ -> typ) -> proof -> proof
val map_proof_terms_same:
term Same.operation -> typ Same.operation -> proof Same.operation
val map_proof_types: (typ -> typ) -> proof -> proof
val map_proof_types_same: typ Same.operation -> proof Same.operation
val maxidx_proof: proof -> int -> int
val no_proof_body: proof_body
val no_skel: proof
val no_thm_proofs: proof -> proof
val norm_proof: Envir.env -> proof -> proof
val norm_proof': Envir.env -> proof -> proof
val normal_skel: proof
val of_sort_proof:
theory -> (typ * class -> proof) -> typ * sort -> proof list
type oracle = string * term
val oracle_ord: oracle * oracle -> order
val oracle_proof: string -> term -> oracle * proof
val peek_status:
proof_body list -> {failed: bool, oracle: bool, unfinished: bool}
val permute_prems_proof: term list -> int -> int -> proof -> proof
val prf_abstract_over: term -> proof -> proof
val prf_add_loose_bnos:
int -> int -> proof -> int list * int list -> int list * int list
val prf_incr_bv: int -> int -> int -> int -> proof -> proof
val prf_loose_Pbvar1: proof -> int -> bool
val prf_loose_bvar1: proof -> int -> bool
val prf_subst_bounds: term list -> proof -> proof
val prf_subst_pbounds: proof list -> proof -> proof
val promise_proof: theory -> serial -> term -> proof
datatype proof =
% of proof * term option
| %% of proof * proof
| AbsP of string * term option * proof
| Abst of string * typ option * proof
| Hyp of term
| MinProof
| OfClass of typ * class
| Oracle of string * term * typ list option
| PAxm of string * term * typ list option
| PBound of int
| PThm of
serial * ((string * term * typ list option) * proof_body future)
| Promise of serial * term * typ list
datatype proof_body =
PBody of
{oracles: (string * term) list,
proof: proof, thms: (serial * thm_node) list}
val proof_combP: proof * proof list -> proof
val proof_combt: proof * term list -> proof
val proof_combt': proof * term option list -> proof
val proof_of: proof_body -> proof
val proofs: int ref
val proofs_enabled: unit -> bool
type pthm = serial * thm_node
val reflexive: proof
val reflexive_axm: proof
val rew_proof: theory -> proof -> proof
val rewrite_proof:
theory ->
(proof * proof) list *
(typ list -> term option list -> proof -> (proof * proof) option)
list -> proof -> proof
val rewrite_proof_notypes:
(proof * proof) list *
(typ list -> term option list -> proof -> (proof * proof) option) list
-> proof -> proof
val rotate_proof: term list -> term -> int -> proof -> proof
val shrink_proof: proof -> proof
val size_of_proof: proof -> int
val strip_combP: proof -> proof * proof list
val strip_combt: proof -> proof * term option list
val strip_shyps_proof:
Sorts.algebra ->
(typ * sort) list ->
(typ * sort) list -> sort list -> proof -> proof
val strip_thm: proof_body -> proof_body
val symmetric: proof -> proof
val symmetric_axm: proof
type thm_node
val thm_node_body: thm_node -> proof_body future
val thm_node_name: thm_node -> string
val thm_node_prop: thm_node -> term
val thm_ord: pthm * pthm -> order
val thm_proof:
theory ->
string ->
sort list ->
term list ->
term ->
(serial * proof_body future) list ->
proof_body -> pthm * proof
val transitive: term -> typ -> proof -> proof -> proof
val transitive_axm: proof
val unconstrain_thm_proof:
theory ->
sort list ->
term ->
(serial * proof_body future) list -> proof_body -> pthm * proof
val unions_oracles: oracle list list -> oracle list
val unions_thms: pthm list list -> pthm list
val varify_proof: term -> (string * sort) list -> proof -> proof
end
structure Proofterm: PROOFTERM
structure Basic_Proofterm: BASIC_PROOFTERM
datatype proof =
% of proof * term option
| %% of proof * proof
| AbsP of string * term option * proof
| Abst of string * typ option * proof
| Hyp of term
| MinProof
| OfClass of typ * class
| Oracle of string * term * typ list option
| PAxm of string * term * typ list option
| PBound of int
| PThm of serial * ((string * term * typ list option) * proof_body future)
| Promise of serial * term * typ list
datatype proof_body =
PBody of
{oracles: (string * term) list,
proof: proof, thms: (serial * thm_node) list}
type thm_node
val %> = fn: proof * term -> proof
val it = (): unit
signature BASIC_THM =
sig
exception CTERM of string * cterm list
exception THM of string * int * thm list
type conv = cterm -> thm
type cterm
type ctyp
type thm
end
signature THM =
sig
exception CONTEXT of
string * ctyp list * cterm list * thm list * Context.generic option
exception CTERM of string * cterm list
exception THM of string * int * thm list
val abstract_rule: string -> cterm -> thm -> thm
val add_oracle:
binding * ('a -> cterm) -> theory -> (string * ('a -> thm)) * theory
val adjust_maxidx_cterm: int -> cterm -> cterm
val adjust_maxidx_thm: int -> thm -> thm
val apply: cterm -> cterm -> cterm
val assume: cterm -> thm
val assumption: Proof.context option -> int -> thm -> thm Seq.seq
val axiom: theory -> string -> thm
val axioms_of: theory -> (string * thm) list
val beta_conversion: bool -> conv
val bicompose:
Proof.context option ->
{flatten: bool, incremented: bool, match: bool} ->
bool * thm * int -> int -> thm -> thm Seq.seq
val biresolution:
Proof.context option ->
bool -> (bool * thm) list -> int -> thm -> thm Seq.seq
val chyps_of: thm -> cterm list
val combination: thm -> thm -> thm
val concl_of: thm -> term
val consolidate: thm list -> unit
type conv = cterm -> thm
val cprem_of: thm -> int -> cterm
val cprop_of: thm -> cterm
type cterm
val cterm_of: Proof.context -> term -> cterm
type ctyp
val ctyp_of: Proof.context -> typ -> ctyp
val ctyp_of_cterm: cterm -> ctyp
val derivation_closed: thm -> bool
val derivation_name: thm -> string
val dest_abs: string option -> cterm -> cterm * cterm
val dest_arg: cterm -> cterm
val dest_arg1: cterm -> cterm
val dest_comb: cterm -> cterm * cterm
val dest_ctyp: ctyp -> ctyp list
val dest_fun: cterm -> cterm
val dest_fun2: cterm -> cterm
val dest_state: thm * int -> (term * term) list * term list * term * term
val eq_assumption: int -> thm -> thm
val equal_elim: thm -> thm -> thm
val equal_intr: thm -> thm -> thm
val eta_conversion: conv
val eta_long_conversion: conv
val extern_oracles: bool -> Proof.context -> (Markup.T * xstring) list
val extra_shyps: thm -> sort list
val first_order_match:
cterm * cterm ->
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list
val flexflex_rule: Proof.context option -> thm -> thm Seq.seq
val fold_atomic_cterms: (cterm -> 'a -> 'a) -> thm -> 'a -> 'a
val fold_atomic_ctyps: (ctyp -> 'a -> 'a) -> thm -> 'a -> 'a
val fold_terms: (term -> 'a -> 'a) -> thm -> 'a -> 'a
val forall_elim: cterm -> thm -> thm
val forall_intr: cterm -> thm -> thm
val full_prop_of: thm -> term
val future: thm future -> cterm -> thm
val generalize: string list * string list -> int -> thm -> thm
val get_tags: thm -> Properties.T
val global_cterm_of: theory -> term -> cterm
val global_ctyp_of: theory -> typ -> ctyp
val hyps_of: thm -> term list
val implies_elim: thm -> thm -> thm
val implies_intr: cterm -> thm -> thm
val incr_indexes: int -> thm -> thm
val incr_indexes_cterm: int -> cterm -> cterm
val instantiate:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
thm -> thm
val instantiate_cterm:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
cterm -> cterm
val lambda: cterm -> cterm -> cterm
val lambda_name: string * cterm -> cterm -> cterm
val legacy_freezeT: thm -> thm
val lift_rule: cterm -> thm -> thm
val major_prem_of: thm -> term
val map_tags: (Properties.T -> Properties.T) -> thm -> thm
val match:
cterm * cterm ->
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list
val maxidx_of: thm -> int
val maxidx_of_cterm: cterm -> int
val maxidx_thm: thm -> int -> int
val name_derivation: string -> thm -> thm
val no_prems: thm -> bool
val norm_proof: thm -> thm
val nprems_of: thm -> int
val of_class: ctyp * class -> thm
val peek_status: thm -> {failed: bool, oracle: bool, unfinished: bool}
val permute_prems: int -> int -> thm -> thm
val prems_of: thm -> term list
val proof_bodies_of: thm list -> proof_body list
val proof_body_of: thm -> proof_body
val proof_of: thm -> proof
val prop_of: thm -> term
val reflexive: cterm -> thm
val rename_tvar: indexname -> ctyp -> ctyp
val renamed_prop: term -> thm -> thm
val renamed_term: term -> cterm -> cterm
val rotate_rule: int -> int -> thm -> thm
val shyps_of: thm -> sort list
val strip_shyps: thm -> thm
val symmetric: thm -> thm
val term_of: cterm -> term
val terms_of_tpairs: (term * term) list -> term list
val theory_id: thm -> Context.theory_id
val theory_name: thm -> string
val theory_of_cterm: cterm -> theory
val theory_of_thm: thm -> theory
type thm
val tpairs_of: thm -> (term * term) list
val transfer: theory -> thm -> thm
val transfer_cterm: theory -> cterm -> cterm
val transitive: thm -> thm -> thm
val trim_context: thm -> thm
val trim_context_cterm: cterm -> cterm
val trivial: cterm -> thm
val typ_of: ctyp -> typ
val typ_of_cterm: cterm -> typ
val unconstrainT: thm -> thm
val var: indexname * ctyp -> cterm
val varifyT_global: thm -> thm
val varifyT_global':
(string * sort) list ->
thm -> ((string * sort) * indexname) list * thm
val weaken: cterm -> thm -> thm
val weaken_sorts: sort list -> cterm -> cterm
end
structure Thm: THM
structure Basic_Thm: BASIC_THM
type conv = cterm -> thm
type cterm
type thm
type ctyp
exception THM of string * int * thm list
exception CTERM of string * cterm list
val it = (): unit
signature PATTERN =
sig
exception MATCH
exception Pattern
exception Unif
val equiv: theory -> term * term -> bool
val first_order: term -> bool
val first_order_match:
theory ->
term * term -> Type.tyenv * Envir.tenv -> Type.tyenv * Envir.tenv
val match:
theory ->
term * term -> Type.tyenv * Envir.tenv -> Type.tyenv * Envir.tenv
val match_rew: theory -> term -> term * term -> (term * term) option
val matches: theory -> term * term -> bool
val matchess: theory -> term list * term list -> bool
val pattern: term -> bool
val rewrite_term:
theory ->
(term * term) list -> (term -> term option) list -> term -> term
val rewrite_term_top:
theory ->
(term * term) list -> (term -> term option) list -> term -> term
val unify: Context.generic -> term * term -> Envir.env -> Envir.env
val unify_trace_failure: bool Config.T
val unify_trace_failure_raw: Config.raw
val unify_types: Context.generic -> typ * typ -> Envir.env -> Envir.env
end
Warning: Value identifier (bounds) has not been referenced.
At (line 98 of "more_pattern.ML")
structure Pattern: PATTERN
val it = (): unit
signature UNIFY =
sig
val hounifiers:
Context.generic * Envir.env * (term * term) list ->
(Envir.env * (term * term) list) Seq.seq
val matchers: Context.generic -> (term * term) list -> Envir.env Seq.seq
val matches_list: Context.generic -> term list -> term list -> bool
val search_bound: int Config.T
val search_bound_raw: Config.raw
val smash_unifiers:
Context.generic ->
(term * term) list -> Envir.env -> Envir.env Seq.seq
val trace_bound: int Config.T
val trace_bound_raw: Config.raw
val trace_simp: bool Config.T
val trace_simp_raw: Config.raw
val trace_types: bool Config.T
val trace_types_raw: Config.raw
val unifiers:
Context.generic * Envir.env * (term * term) list ->
(Envir.env * (term * term) list) Seq.seq
end
structure Unify: UNIFY
val it = (): unit
infix 0 aconvc
signature BASIC_THM =
sig
exception CTERM of string * cterm list
structure Ctermtab: TABLE
exception THM of string * int * thm list
structure Thmtab: TABLE
val aconvc: cterm * cterm -> bool
type attribute =
Context.generic * thm -> Context.generic option * thm option
type conv = cterm -> thm
type cterm
type ctyp
val show_consts: bool Config.T
val show_hyps: bool Config.T
val show_tags: bool Config.T
type thm
end
signature THM =
sig
exception CONTEXT of
string * ctyp list * cterm list * thm list * Context.generic option
exception CTERM of string * cterm list
structure Ctermtab: TABLE
exception THM of string * int * thm list
structure Thmtab: TABLE
val abstract_rule: string -> cterm -> thm -> thm
val aconvc: cterm * cterm -> bool
val add_axiom:
Proof.context ->
Binding.binding * term -> theory -> (string * thm) * theory
val add_axiom_global:
Binding.binding * term -> theory -> (string * thm) * theory
val add_def:
Defs.context ->
bool ->
bool ->
Binding.binding * term -> theory -> (string * thm) * theory
val add_def_global:
bool ->
bool -> Binding.binding * term -> theory -> (string * thm) * theory
val add_frees: thm -> cterm list -> cterm list
val add_oracle:
Binding.binding * ('a -> cterm) ->
theory -> (string * ('a -> thm)) * theory
val add_thm: thm -> thm list -> thm list
val add_tvars: thm -> ctyp list -> ctyp list
val add_vars: thm -> cterm list -> cterm list
val adjust_maxidx_cterm: int -> cterm -> cterm
val adjust_maxidx_thm: int -> thm -> thm
val all: Proof.context -> cterm -> cterm -> cterm
val all_name: Proof.context -> string * cterm -> cterm -> cterm
val apply: cterm -> cterm -> cterm
val apply_attribute:
attribute -> thm -> Context.generic -> thm * Context.generic
val assume: cterm -> thm
val assume_hyps: cterm -> Proof.context -> thm * Proof.context
val assumption: Proof.context option -> int -> thm -> thm Seq.seq
type attribute =
Context.generic * thm -> Context.generic option * thm option
val attribute_declaration:
attribute -> thm -> Context.generic -> Context.generic
val axiom: theory -> string -> thm
val axioms_of: theory -> (string * thm) list
val beta_conversion: bool -> conv
val bicompose:
Proof.context option ->
{flatten: bool, incremented: bool, match: bool} ->
bool * thm * int -> int -> thm -> thm Seq.seq
type binding = Binding.binding * attribute list
val biresolution:
Proof.context option ->
bool -> (bool * thm) list -> int -> thm -> thm Seq.seq
val check_hyps: Context.generic -> thm -> thm
val check_shyps: Proof.context -> thm -> thm
val chyps_of: thm -> cterm list
val class_triv: theory -> class -> thm
val close_derivation: thm -> thm
val combination: thm -> thm -> thm
val concl_of: thm -> term
val consolidate: thm list -> unit
val consolidate_theory: theory -> unit
type conv = cterm -> thm
val cprem_of: thm -> int -> cterm
val cprop_of: thm -> cterm
type cterm
val cterm_cache: (cterm -> 'a) -> cterm -> 'a
val cterm_of: Proof.context -> term -> cterm
type ctyp
val ctyp_of: Proof.context -> typ -> ctyp
val ctyp_of_cterm: cterm -> ctyp
val declaration_attribute:
(thm -> Context.generic -> Context.generic) -> attribute
val declare_hyps: cterm -> Proof.context -> Proof.context
val declare_term_sorts: term -> Proof.context -> Proof.context
val def_binding: Binding.binding -> Binding.binding
val def_binding_optional:
Binding.binding -> Binding.binding -> Binding.binding
val def_name: string -> string
val def_name_optional: string -> string -> string
val del_thm: thm -> thm list -> thm list
val derivation_closed: thm -> bool
val derivation_name: thm -> string
val dest_abs: string option -> cterm -> cterm * cterm
val dest_arg: cterm -> cterm
val dest_arg1: cterm -> cterm
val dest_binop: cterm -> cterm * cterm
val dest_comb: cterm -> cterm * cterm
val dest_ctyp: ctyp -> ctyp list
val dest_equals: cterm -> cterm * cterm
val dest_equals_lhs: cterm -> cterm
val dest_equals_rhs: cterm -> cterm
val dest_fun: cterm -> cterm
val dest_fun2: cterm -> cterm
val dest_implies: cterm -> cterm * cterm
val dest_state: thm * int -> (term * term) list * term list * term * term
val elim_implies: thm -> thm -> thm
val elim_rules: thm Item_Net.T
val eq_assumption: int -> thm -> thm
val eq_ctyp: ctyp * ctyp -> bool
val eq_thm: thm * thm -> bool
val eq_thm_prop: thm * thm -> bool
val eq_thm_strict: thm * thm -> bool
val equal_elim: thm -> thm -> thm
val equal_intr: thm -> thm -> thm
val equiv_thm: theory -> thm * thm -> bool
val eta_conversion: conv
val eta_long_conversion: conv
val extern_oracles: bool -> Proof.context -> (Markup.T * xstring) list
val extra_shyps: thm -> sort list
val extra_shyps': Proof.context -> thm -> sort list
val first_order_match:
cterm * cterm ->
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list
val flexflex_rule: Proof.context option -> thm -> thm Seq.seq
val fold_atomic_cterms: (cterm -> 'a -> 'a) -> thm -> 'a -> 'a
val fold_atomic_ctyps: (ctyp -> 'a -> 'a) -> thm -> 'a -> 'a
val fold_terms: (term -> 'a -> 'a) -> thm -> 'a -> 'a
val forall_elim: cterm -> thm -> thm
val forall_elim_var: int -> thm -> thm
val forall_elim_vars: int -> thm -> thm
val forall_intr: cterm -> thm -> thm
val forall_intr_frees: thm -> thm
val forall_intr_name: string * cterm -> thm -> thm
val full_prop_of: thm -> term
val full_rules: thm Item_Net.T
val future: thm future -> cterm -> thm
val generalize: string list * string list -> int -> thm -> thm
val get_name_hint: thm -> string
val get_tags: thm -> Properties.T
val global_cterm_of: theory -> term -> cterm
val global_ctyp_of: theory -> typ -> ctyp
val has_name_hint: thm -> bool
val hyps_of: thm -> term list
val implies_elim: thm -> thm -> thm
val implies_intr: cterm -> thm -> thm
val incr_indexes: int -> thm -> thm
val incr_indexes_cterm: int -> cterm -> cterm
val instantiate:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
thm -> thm
val instantiate': ctyp option list -> cterm option list -> thm -> thm
val instantiate_cterm:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
cterm -> cterm
val intro_rules: thm Item_Net.T
val is_dummy: thm -> bool
val is_free_dummy: thm -> bool
val is_reflexive: thm -> bool
val kind: string -> attribute
val kind_rule: string -> thm -> thm
val lambda: cterm -> cterm -> cterm
val lambda_name: string * cterm -> cterm -> cterm
val legacy_freezeT: thm -> thm
val legacy_get_kind: thm -> string
val lhs_of: thm -> cterm
val lift_rule: cterm -> thm -> thm
val major_prem_of: thm -> term
val make_def_binding: bool -> Binding.binding -> Binding.binding
val map_tags: (Properties.T -> Properties.T) -> thm -> thm
val match:
cterm * cterm ->
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list
val maxidx_of: thm -> int
val maxidx_of_cterm: cterm -> int
val maxidx_thm: thm -> int -> int
val merge_thms: thm list * thm list -> thm list
val mixed_attribute:
(Context.generic * thm -> Context.generic * thm) -> attribute
val mk_binop: cterm -> cterm -> cterm -> cterm
val name_derivation: string -> thm -> thm
val no_attributes: 'a -> 'a * 'b list
val no_prems: thm -> bool
val norm_proof: thm -> thm
val nprems_of: thm -> int
val of_class: ctyp * class -> thm
val of_sort: ctyp * sort -> thm list
val peek_status: thm -> {failed: bool, oracle: bool, unfinished: bool}
val permute_prems: int -> int -> thm -> thm
val plain_prop_of: thm -> term
val prems_of: thm -> term list
val pretty_flexpair: Proof.context -> term * term -> Pretty.T
val pretty_thm: Proof.context -> thm -> Pretty.T
val pretty_thm_global: theory -> thm -> Pretty.T
val pretty_thm_item: Proof.context -> thm -> Pretty.T
val pretty_thm_raw:
Proof.context -> {quote: bool, show_hyps: bool} -> thm -> Pretty.T
val proof_attributes:
attribute list -> thm -> Proof.context -> thm * Proof.context
val proof_bodies_of: thm list -> proof_body list
val proof_body_of: thm -> proof_body
val proof_of: thm -> proof
val prop_of: thm -> term
val put_name_hint: string -> thm -> thm
val reflexive: cterm -> thm
val register_proofs: thm list -> theory -> theory
val rename_boundvars: term -> term -> thm -> thm
val rename_params_rule: string list * int -> thm -> thm
val rename_tvar: indexname -> ctyp -> ctyp
val renamed_prop: term -> thm -> thm
val renamed_term: term -> cterm -> cterm
val restore_hyps: Proof.context -> Proof.context -> Proof.context
val rhs_of: thm -> cterm
val rotate_rule: int -> int -> thm -> thm
val rule_attribute:
thm list -> (Context.generic -> thm -> thm) -> attribute
val show_consts: bool Config.T
val show_consts_raw: Config.raw
val show_hyps: bool Config.T
val show_hyps_raw: Config.raw
val show_tags: bool Config.T
val show_tags_raw: Config.raw
val shyps_of: thm -> sort list
val simple_fact: 'a -> ('a * 'b list) list
val string_of_thm: Proof.context -> thm -> string
val string_of_thm_global: theory -> thm -> string
val strip_shyps: thm -> thm
val symmetric: thm -> thm
val tag: string * string -> attribute
val tag_free_dummy: thm -> thm
val tag_rule: string * string -> thm -> thm
val term_of: cterm -> term
val terms_of_tpairs: (term * term) list -> term list
val theoremK: string
val theory_attributes: attribute list -> thm -> theory -> thm * theory
val theory_id: thm -> Context.theory_id
val theory_name: thm -> string
val theory_of_cterm: cterm -> theory
val theory_of_thm: thm -> theory
type thm
val thm_cache: (thm -> 'a) -> thm -> 'a
val thm_ord: thm * thm -> order
val tpairs_of: thm -> (term * term) list
val transfer: theory -> thm -> thm
val transfer_cterm: theory -> cterm -> cterm
val transitive: thm -> thm -> thm
val trim_context: thm -> thm
val trim_context_cterm: cterm -> cterm
val trivial: cterm -> thm
val typ_of: ctyp -> typ
val typ_of_cterm: cterm -> typ
val unchecked_hyps: Proof.context -> Proof.context
val unconstrainT: thm -> thm
val undeclared_hyps: Context.generic -> thm -> term list
val untag: string -> attribute
val untag_rule: string -> thm -> thm
val unvarify_axiom: theory -> string -> thm
val unvarify_global: theory -> thm -> thm
val var: indexname * ctyp -> cterm
val varifyT_global: thm -> thm
val varifyT_global':
(string * sort) list ->
thm -> ((string * sort) * indexname) list * thm
val weaken: cterm -> thm -> thm
val weaken_sorts: sort list -> cterm -> cterm
val weaken_sorts': Proof.context -> cterm -> cterm
end
Warning: Matches are not exhaustive.
case Thm.prop_of th' of all $ Abs (_, ...) => all $ Abs (a, ...)
At (line 356 of "more_thm.ML")
Warning: Matches are not exhaustive.
fn (TFree (_, ...), T) => (T, S)
At (line 510 of "more_thm.ML")
Warning: Matches are not exhaustive.
fn (T as TFree (...), _) => of_sort (... ... T, S)
At (line 511 of "more_thm.ML")
structure Thm: THM
structure Basic_Thm: BASIC_THM
type thm
type attribute = Context.generic * thm -> Context.generic option * thm option
type cterm
type ctyp
type conv = cterm -> thm
structure Thmtab: TABLE
structure Ctermtab: TABLE
val show_consts =
Config
{get_value = fn, map_value = fn, name = "show_consts", pos =
{line=656, file=more_thm.ML}}: bool Config.T
exception THM of string * int * thm list
val show_hyps =
Config
{get_value = fn, map_value = fn, name = "show_hyps", pos =
{line=659, file=more_thm.ML}}: bool Config.T
val show_tags =
Config
{get_value = fn, map_value = fn, name = "show_tags", pos =
{line=662, file=more_thm.ML}}: bool Config.T
val aconvc = fn: cterm * cterm -> bool
exception CTERM of string * cterm list
val it = (): unit
signature FACTS =
sig
type T
val add_dynamic:
Context.generic ->
binding * (Context.generic -> thm list) -> T -> string * T
val add_static:
Context.generic ->
{index: bool, strict: bool} -> binding * thm list -> T -> string * T
val alias: Name_Space.naming -> binding -> string -> T -> T
val check: Context.generic -> T -> xstring * Position.T -> string
val could_unify: T -> term -> (thm * Position.T) list
val defined: T -> string -> bool
val del: string -> T -> T
val dest_all:
Context.generic -> bool -> T list -> T -> (string * thm list) list
val dest_static: bool -> T list -> T -> (string * thm list) list
val empty: T
val extern: Proof.context -> T -> string -> xstring
val fold_static: (string * thm list -> 'a -> 'a) -> T -> 'a -> 'a
val hide: bool -> string -> T -> T
val intern: T -> xstring -> string
datatype interval = From of int | FromTo of int * int | Single of int
val is_concealed: T -> string -> bool
val is_dynamic: T -> string -> bool
val lookup:
Context.generic ->
T -> string -> {dynamic: bool, thms: thm list} option
val map_name_of_ref: (string -> string) -> ref -> ref
val markup_extern: Proof.context -> T -> string -> Markup.T * xstring
val merge: T * T -> T
val name_of_ref: ref -> string
val named: string -> ref
val pos_of_ref: ref -> Position.T
val props: T -> (thm * Position.T) list
datatype ref =
Fact of string
| Named of (string * Position.T) * interval list option
val retrieve:
Context.generic ->
T ->
xstring * Position.T ->
{dynamic: bool, name: string, thms: thm list}
val select: ref -> thm list -> thm list
val selections: string * thm list -> (ref * thm) list
val space_of: T -> Name_Space.T
val string_of_ref: ref -> string
val string_of_selection: interval list option -> string
val the_single: string * Position.T -> thm list -> thm
end
structure Facts: FACTS
val it = (): unit
signature GLOBAL_THEORY =
sig
val add_defs:
bool ->
((binding * term) * attribute list) list ->
theory -> thm list * theory
val add_defs_unchecked:
bool ->
((binding * term) * attribute list) list ->
theory -> thm list * theory
val add_thm: (binding * thm) * attribute list -> theory -> thm * theory
val add_thms:
((binding * thm) * attribute list) list -> theory -> thm list * theory
val add_thms_dynamic:
binding * (Context.generic -> thm list) -> theory -> theory
val add_thms_dynamic':
Context.generic ->
binding * (Context.generic -> thm list) -> theory -> string * theory
val add_thmss:
((binding * thm list) * attribute list) list ->
theory -> thm list list * theory
val alias_fact: binding -> string -> theory -> theory
val all_thms_of: theory -> bool -> (string * thm) list
val burrow_fact:
('a list -> 'b list) -> ('a list * 'c) list -> ('b list * 'c) list
val burrow_facts:
('a list -> 'b list) ->
('c * ('a list * 'd) list) list -> ('c * ('b list * 'd) list) list
val check_fact: theory -> xstring * Position.T -> string
val defined_fact: theory -> string -> bool
val facts_of: theory -> Facts.T
val get_thm: theory -> xstring -> thm
val get_thms: theory -> xstring -> thm list
val hide_fact: bool -> string -> theory -> theory
val intern_fact: theory -> xstring -> string
val map_facts:
('a -> 'b) ->
('c * ('a list * 'd) list) list -> ('c * ('b list * 'd) list) list
val name_multi: string -> 'a list -> (string * 'a) list
val name_thm: bool -> bool -> string -> thm -> thm
val name_thms: bool -> bool -> string -> thm list -> thm list
val name_thmss:
bool -> string -> (thm list * 'a) list -> (thm list * 'a) list
val note_thmss:
string ->
(Thm.binding * (thm list * attribute list) list) list ->
theory -> (string * thm list) list * theory
val store_thm: binding * thm -> theory -> thm * theory
val store_thm_open: binding * thm -> theory -> thm * theory
val store_thms: binding * thm list -> theory -> thm list * theory
val transfer_theories: theory -> thm -> thm
end
structure Global_Theory: GLOBAL_THEORY
val it = (): unit
signature PURE_THY =
sig
val old_appl_syntax: theory -> bool
val old_appl_syntax_setup: theory -> theory
val token_markers: string list
end
structure Pure_Thy: PURE_THY
val it = (): unit
infix 0 RS
infix 0 RSN
infix 0 RL
infix 0 RLN
infix 0 MRS
infix 0 OF
infix 0 COMP
infix 0 INCR_COMP
infix 0 COMP_INCR
signature BASIC_DRULE =
sig
val COMP: thm * thm -> thm
val COMP_INCR: thm * thm -> thm
val INCR_COMP: thm * thm -> thm
val MRS: thm list * thm -> thm
val OF: thm * thm list -> thm
val RL: thm list * thm list -> thm list
val RLN: thm list * (int * thm list) -> thm list
val RS: thm * thm -> thm
val RSN: thm * (int * thm) -> thm
val asm_rl: thm
val cprems_of: thm -> cterm list
val cut_rl: thm
val extensional: thm -> thm
val forall_elim_list: cterm list -> thm -> thm
val forall_intr_list: cterm list -> thm -> thm
val forall_intr_vars: thm -> thm
val implies_elim_list: thm -> thm list -> thm
val implies_intr_hyps: thm -> thm
val implies_intr_list: cterm list -> thm -> thm
val infer_instantiate:
Proof.context -> (indexname * cterm) list -> thm -> thm
val infer_instantiate': Proof.context -> cterm option list -> thm -> thm
val infer_instantiate_types:
Proof.context -> ((indexname * typ) * cterm) list -> thm -> thm
val instantiate_normalize:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
thm -> thm
val lift_all: Proof.context -> cterm -> thm -> thm
val list_implies: cterm list * cterm -> cterm
val mk_implies: cterm * cterm -> cterm
val rearrange_prems: int list -> thm -> thm
val reflexive_thm: thm
val revcut_rl: thm
val rotate_prems: int -> thm -> thm
val size_of_thm: thm -> int
val strip_imp_concl: cterm -> cterm
val strip_imp_prems: cterm -> cterm list
val symmetric_thm: thm
val thin_rl: thm
val transitive_thm: thm
val zero_var_indexes: thm -> thm
val zero_var_indexes_list: thm list -> thm list
end
signature DRULE =
sig
val COMP: thm * thm -> thm
val COMP_INCR: thm * thm -> thm
val INCR_COMP: thm * thm -> thm
val MRS: thm list * thm -> thm
val OF: thm * thm list -> thm
val RL: thm list * thm list -> thm list
val RLN: thm list * (int * thm list) -> thm list
val RS: thm * thm -> thm
val RSN: thm * (int * thm) -> thm
val abs_def: thm -> thm
val arg_cong_rule: cterm -> thm -> thm
val asm_rl: thm
val beta_conv: cterm -> cterm -> cterm
val beta_eta_conversion: cterm -> thm
val binop_cong_rule: cterm -> thm -> thm -> thm
val comp_no_flatten: thm * int -> int -> thm -> thm
val compose: thm * int * thm -> thm
val cprems_of: thm -> cterm list
val cterm_add_frees: cterm -> cterm list -> cterm list
val cterm_add_vars: cterm -> cterm list -> cterm list
val cterm_rule: (thm -> thm) -> cterm -> cterm
val cut_rl: thm
val dest_term: thm -> cterm
val distinct_prems_rl: thm
val dummy_thm: thm
val equal_elim_rule1: thm
val equal_elim_rule2: thm
val equal_intr_rule: thm
val equals_cong: thm
val eta_contraction_rule: thm -> thm
val export_without_context: thm -> thm
val export_without_context_open: thm -> thm
val extensional: thm -> thm
val flexflex_unique: Proof.context option -> thm -> thm
val forall_elim_list: cterm list -> thm -> thm
val forall_intr_list: cterm list -> thm -> thm
val forall_intr_vars: thm -> thm
val free_dummy_thm: thm
val fun_cong_rule: thm -> cterm -> thm
val generalize: string list * string list -> thm -> thm
val imp_cong: thm
val imp_cong_rule: thm -> thm -> thm
val implies_elim_list: thm -> thm list -> thm
val implies_intr_hyps: thm -> thm
val implies_intr_list: cterm list -> thm -> thm
val implies_intr_protected: cterm list -> thm -> thm
val incr_indexes: thm -> thm -> thm
val incr_indexes2: thm -> thm -> thm -> thm
val infer_instantiate:
Proof.context -> (indexname * cterm) list -> thm -> thm
val infer_instantiate': Proof.context -> cterm option list -> thm -> thm
val infer_instantiate_types:
Proof.context -> ((indexname * typ) * cterm) list -> thm -> thm
val instantiate_normalize:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
thm -> thm
val is_norm_hhf: term -> bool
val is_sort_constraint: term -> bool
val lift_all: Proof.context -> cterm -> thm -> thm
val list_comb: cterm * cterm list -> cterm
val list_implies: cterm list * cterm -> cterm
val mk_implies: cterm * cterm -> cterm
val mk_term: cterm -> thm
val multi_resolve: Proof.context option -> thm list -> thm -> thm Seq.seq
val multi_resolves:
Proof.context option -> thm list -> thm list -> thm Seq.seq
val norm_hhf: theory -> term -> term
val norm_hhf_cterm: Proof.context -> cterm -> cterm
val norm_hhf_eq: thm
val norm_hhf_eqs: thm list
val outer_params: term -> (string * typ) list
val protect: cterm -> cterm
val protectD: thm
val protectI: thm
val protect_cong: thm
val rearrange_prems: int list -> thm -> thm
val reflexive_thm: thm
val remdups_rl: thm
val rename_bvars: (string * string) list -> thm -> thm
val rename_bvars': string option list -> thm -> thm
val revcut_rl: thm
val rotate_prems: int -> thm -> thm
val size_of_thm: thm -> int
val sort_constraintI: thm
val sort_constraint_eq: thm
val store_standard_thm: binding -> thm -> thm
val store_standard_thm_open: binding -> thm -> thm
val store_thm: binding -> thm -> thm
val store_thm_open: binding -> thm -> thm
val strip_comb: cterm -> cterm * cterm list
val strip_imp_concl: cterm -> cterm
val strip_imp_prems: cterm -> cterm list
val strip_type: ctyp -> ctyp list * ctyp
val swap_prems_eq: thm
val symmetric_thm: thm
val termI: thm
val thin_rl: thm
val transitive_thm: thm
val triv_forall_equality: thm
val with_subgoal: int -> (thm -> thm) -> thm -> thm
val zero_var_indexes: thm -> thm
val zero_var_indexes_list: thm list -> thm list
end
Warning: Pattern is not exhaustive.
val [cT1, cT2] = Thm.dest_ctyp cT
At (line 162 of "drule.ML")
Warning: Matches are not exhaustive.
fn (v, TVar (...)) => (v, ... ... (... ...))
At (line 227 of "drule.ML")
Warning: Matches are not exhaustive.
fn (v, Var (...)) => (v, Thm.var (...))
At (line 231 of "drule.ML")
Warning: Value identifier (new) has not been referenced.
At (line 283 of "drule.ML")
structure Drule: DRULE
structure Basic_Drule: BASIC_DRULE
val infer_instantiate_types = fn:
Proof.context -> ((indexname * typ) * cterm) list -> thm -> thm
val RSN = fn: thm * (int * thm) -> thm
val OF = fn: thm * thm list -> thm
val zero_var_indexes = fn: thm -> thm
val forall_intr_vars = fn: thm -> thm
val asm_rl =
Thm
(Deriv
{body =
PBody {oracles = [], proof = AbsP ("H", NONE, PBound 0), thms = []},
promises = []},
{cert = Certificate {Pure:66}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
Var (("psi", 0), Type ("prop", []))),
Var (("psi", 0), Type ("prop", []))), shyps = [], tags =
[("name", "Pure.asm_rl")], tpairs = []}): thm
val implies_intr_list = fn: cterm list -> thm -> thm
val lift_all = fn: Proof.context -> cterm -> thm -> thm
val forall_elim_list = fn: cterm list -> thm -> thm
val RS = fn: thm * thm -> thm
val strip_imp_prems = fn: cterm -> cterm list
val symmetric_thm =
Thm
(Deriv
{body =
PBody
{oracles = [], proof =
%
(%
(Abst
("x", NONE,
Abst
("y", NONE, AbsP ("H", NONE, %% (% (..., ...), PBound 0)))),
SOME (Var (("x", 0), TVar (("'a", 0), [])))),
SOME (Var (("y", 0), TVar (("'a", 0), [])))), thms = []},
promises = []},
{cert = Certificate {Pure:56}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
$
($
(Const
("Pure.eq",
Type
("fun",
[TVar (("'a", 0), []),
Type
("fun", [TVar (("'a", 0), [...]), Type ("prop", [...])])])),
Var (("x", 0), TVar (("'a", 0), []))),
Var (("y", 0), TVar (("'a", 0), [])))),
$
($
(Const
("Pure.eq",
Type
("fun",
[TVar (("'a", 0), []),
Type ("fun", [TVar (("'a", 0), []), Type ("prop", [])])])),
Var (("y", 0), TVar (("'a", 0), []))),
Var (("x", 0), TVar (("'a", 0), [])))), shyps = [[]], tags =
[("name", "Pure.symmetric")], tpairs = []}): thm
val implies_elim_list = fn: thm -> thm list -> thm
val RLN = fn: thm list * (int * thm list) -> thm list
val list_implies = fn: cterm list * cterm -> cterm
val rearrange_prems = fn: int list -> thm -> thm
val COMP_INCR = fn: thm * thm -> thm
val transitive_thm =
Thm
(Deriv
{body =
PBody
{oracles = [], proof =
%
(%
(%
(Abst
("x", NONE,
Abst ("y", NONE, Abst ("z", NONE, AbsP ("H", ..., ...)))),
SOME (Var (("x", 0), TVar (("'a", 0), [])))),
SOME (Var (("y", 0), TVar (("'a", 0), [])))),
SOME (Var (("z", 0), TVar (("'a", 0), [])))), thms = []},
promises = []},
{cert = Certificate {Pure:58}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
$
($
(Const
("Pure.eq",
Type
("fun",
[TVar (("'a", 0), []),
Type
("fun", [TVar (("'a", 0), [...]), Type ("prop", [...])])])),
Var (("x", 0), TVar (("'a", 0), []))),
Var (("y", 0), TVar (("'a", 0), [])))),
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
$
($
(Const
("Pure.eq",
Type ("fun", [TVar (("'a", 0), []), Type ("fun", [...])])),
Var (("y", 0), TVar (("'a", 0), []))),
Var (("z", 0), TVar (("'a", 0), [])))),
$
($
(Const
("Pure.eq",
Type
("fun",
[TVar (("'a", 0), []),
Type
("fun", [TVar (("'a", 0), [...]), Type ("prop", [...])])])),
Var (("x", 0), TVar (("'a", 0), []))),
Var (("z", 0), TVar (("'a", 0), []))))), shyps = [[]], tags =
[("name", "Pure.transitive")], tpairs = []}): thm
val infer_instantiate = fn:
Proof.context -> (indexname * cterm) list -> thm -> thm
val infer_instantiate' = fn: Proof.context -> cterm option list -> thm -> thm
val rotate_prems = fn: int -> thm -> thm
val reflexive_thm =
Thm
(Deriv
{body =
PBody
{oracles = [], proof =
%
(PAxm
("Pure.reflexive",
$
($
(Const
("Pure.eq",
Type
("fun", [TVar (("'a", 0), [...]), Type ("fun", [...])])),
Var (("x", 0), TVar (("'a", 0), []))),
Var (("x", 0), TVar (("'a", 0), []))), NONE), NONE), thms =
[]}, promises = []},
{cert = Certificate {Pure:54}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.eq",
Type
("fun",
[TVar (("'a", 0), []),
Type ("fun", [TVar (("'a", 0), []), Type ("prop", [])])])),
Var (("x", 0), TVar (("'a", 0), []))),
Var (("x", 0), TVar (("'a", 0), []))), shyps = [[]], tags =
[("name", "Pure.reflexive")], tpairs = []}): thm
val RL = fn: thm list * thm list -> thm list
val instantiate_normalize = fn:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list ->
thm -> thm
val cprems_of = fn: thm -> cterm list
val cut_rl =
Thm
(Deriv
{body =
PBody {oracles = [], proof = AbsP ("H", NONE, PBound 0), thms = []},
promises = []},
{cert = Certificate {Pure:68}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", [...]), Type ("prop", [...])])])),
Var (("psi", 0), Type ("prop", []))),
Var (("theta", 0), Type ("prop", [])))),
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
Var (("psi", 0), Type ("prop", []))),
Var (("theta", 0), Type ("prop", [])))), shyps = [], tags =
[("name", "Pure.cut_rl")], tpairs = []}): thm
val mk_implies = fn: cterm * cterm -> cterm
val thin_rl =
Thm
(Deriv
{body =
PBody
{oracles = [], proof =
%
(%
(Abst
("V", NONE,
Abst ("W", NONE, AbsP ("H", NONE, AbsP ("H", NONE, PBound 0)))),
SOME (Var (("V", 0), Type ("prop", [])))),
SOME (Var (("W", 0), Type ("prop", [])))), thms = []}, promises =
[]},
{cert = Certificate {Pure:72}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
Var (("V", 0), Type ("prop", []))),
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
Var (("W", 0), Type ("prop", []))),
Var (("W", 0), Type ("prop", [])))), shyps = [], tags =
[("name", "Pure.thin_rl")], tpairs = []}): thm
val size_of_thm = fn: thm -> int
val implies_intr_hyps = fn: thm -> thm
val strip_imp_concl = fn: cterm -> cterm
val zero_var_indexes_list = fn: thm list -> thm list
val forall_intr_list = fn: cterm list -> thm -> thm
val revcut_rl =
Thm
(Deriv
{body =
PBody
{oracles = [], proof =
%
(%
(Abst
("V", NONE,
Abst
("W", NONE,
AbsP ("H", NONE, AbsP ("H", NONE, %% (..., ...))))),
SOME (Var (("V", 0), Type ("prop", [])))),
SOME (Var (("W", 0), Type ("prop", [])))), thms = []}, promises =
[]},
{cert = Certificate {Pure:70}, hyps = [], maxidx = 0, prop =
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
Var (("V", 0), Type ("prop", []))),
$
($
(Const
("Pure.imp",
Type
("fun",
[Type ("prop", []),
Type ("fun", [Type ("prop", []), Type ("prop", [])])])),
$
($
(Const
("Pure.imp",
Type ("fun", [Type ("prop", []), Type ("fun", [...])])),
Var (("V", 0), Type ("prop", []))),
Var (("W", 0), Type ("prop", [])))),
Var (("W", 0), Type ("prop", [])))), shyps = [], tags =
[("name", "Pure.revcut_rl")], tpairs = []}): thm
val extensional = fn: thm -> thm
val COMP = fn: thm * thm -> thm
val INCR_COMP = fn: thm * thm -> thm
val MRS = fn: thm list * thm -> thm
val it = (): unit
infix 1 $>
signature BASIC_MORPHISM =
sig
val $>: morphism * morphism -> morphism
type declaration = morphism -> Context.generic -> Context.generic
type morphism
end
signature MORPHISM =
sig
val $>: morphism * morphism -> morphism
exception MORPHISM of string * exn
val binding: morphism -> binding -> binding
val binding_morphism: string -> (binding -> binding) -> morphism
val compose: morphism -> morphism -> morphism
val cterm: morphism -> cterm -> cterm
type declaration = morphism -> Context.generic -> Context.generic
val fact: morphism -> thm list -> thm list
val fact_morphism: string -> (thm list -> thm list) -> morphism
val form: (morphism -> 'a) -> 'a
val identity: morphism
val morphism:
string ->
{binding: (binding -> binding) list,
fact: (thm list -> thm list) list,
term: (term -> term) list, typ: (typ -> typ) list} -> morphism
type morphism
val pretty: morphism -> Pretty.T
val term: morphism -> term -> term
val term_morphism: string -> (term -> term) -> morphism
val thm: morphism -> thm -> thm
val thm_morphism: string -> (thm -> thm) -> morphism
val transfer_morphism: theory -> morphism
val transform: morphism -> (morphism -> 'a) -> morphism -> 'a
val trim_context_morphism: morphism
val typ: morphism -> typ -> typ
val typ_morphism: string -> (typ -> typ) -> morphism
end
Warning: Handler catches all exceptions.
f x
handle
exn =>
if Exn.is_interrupt exn then Exn.reraise exn else raise MORPHISM (...)
At (line 55 of "morphism.ML")
structure Morphism: MORPHISM
structure Basic_Morphism: BASIC_MORPHISM
type declaration = morphism -> Context.generic -> Context.generic
type morphism
val $> = fn: morphism * morphism -> morphism
val it = (): unit
signature VARIABLE =
sig
val add_fixed:
Proof.context -> term -> (string * typ) list -> (string * typ) list
val add_fixed_names: Proof.context -> term -> string list -> string list
val add_fixes:
string list -> Proof.context -> string list * Proof.context
val add_fixes_binding:
binding list -> Proof.context -> string list * Proof.context
val add_fixes_direct: string list -> Proof.context -> Proof.context
val add_free_names: Proof.context -> term -> string list -> string list
val add_frees:
Proof.context -> term -> (string * typ) list -> (string * typ) list
val add_newly_fixed:
Proof.context ->
Proof.context -> term -> (string * typ) list -> (string * typ) list
val auto_fixes: term -> Proof.context -> Proof.context
val bind_term: indexname * term -> Proof.context -> Proof.context
val binds_of: Proof.context -> (typ * term) Vartab.table
val check_name: binding -> string
val constraints_of: Proof.context -> typ Vartab.table * sort Vartab.table
val declare_const: string * string -> Proof.context -> Proof.context
val declare_constraints: term -> Proof.context -> Proof.context
val declare_internal: term -> Proof.context -> Proof.context
val declare_maxidx: int -> Proof.context -> Proof.context
val declare_names: term -> Proof.context -> Proof.context
val declare_prf: proof -> Proof.context -> Proof.context
val declare_term: term -> Proof.context -> Proof.context
val declare_thm: thm -> Proof.context -> Proof.context
val declare_typ: typ -> Proof.context -> Proof.context
val def_sort: Proof.context -> indexname -> sort option
val def_type: Proof.context -> bool -> indexname -> typ option
val default_type: Proof.context -> string -> typ option
val dest_fixes: Proof.context -> (string * string) list
val expand_binds: Proof.context -> term -> term
val export: Proof.context -> Proof.context -> thm list -> thm list
val exportT: Proof.context -> Proof.context -> thm list -> thm list
val exportT_terms:
Proof.context -> Proof.context -> term list -> term list
val export_morphism: Proof.context -> Proof.context -> morphism
val export_prf: Proof.context -> Proof.context -> proof -> proof
val export_terms:
Proof.context -> Proof.context -> term list -> term list
val fix_dummy_patterns: term -> Proof.context -> term * Proof.context
val fixed_ord: Proof.context -> string * string -> order
val focus:
binding list option ->
term ->
Proof.context ->
((string * (string * typ)) list * term) * Proof.context
val focus_cterm:
binding list option ->
cterm ->
Proof.context -> ((string * cterm) list * cterm) * Proof.context
val focus_params:
binding list option ->
term ->
Proof.context ->
(string list * (string * typ) list) * Proof.context
val focus_subgoal:
binding list option ->
int ->
thm ->
Proof.context -> ((string * cterm) list * cterm) * Proof.context
val gen_all: Proof.context -> thm -> thm
val import:
bool ->
thm list ->
Proof.context ->
((((indexname * sort) * ctyp) list *
((indexname * typ) * cterm) list) * thm list) * Proof.context
val importT:
thm list ->
Proof.context ->
(((indexname * sort) * ctyp) list * thm list) * Proof.context
val importT_inst:
term list ->
Proof.context -> ((indexname * sort) * typ) list * Proof.context
val importT_terms:
term list -> Proof.context -> term list * Proof.context
val import_inst:
bool ->
term list ->
Proof.context ->
(((indexname * sort) * typ) list *
((indexname * typ) * term) list) * Proof.context
val import_prf: bool -> proof -> Proof.context -> proof * Proof.context
val import_terms:
bool -> term list -> Proof.context -> term list * Proof.context
val improper_fixes: Proof.context -> Proof.context
val intern_fixed: Proof.context -> string -> string
val invent_types:
sort list -> Proof.context -> (string * sort) list * Proof.context
val is_body: Proof.context -> bool
val is_bound_focus: Proof.context -> bool
val is_const: Proof.context -> string -> bool
val is_declared: Proof.context -> string -> bool
val is_fixed: Proof.context -> string -> bool
val is_improper: Proof.context -> string -> bool
val is_newly_fixed: Proof.context -> Proof.context -> string -> bool
val lookup_const: Proof.context -> string -> string option
val lookup_fixed: Proof.context -> string -> string option
val markup: Proof.context -> string -> Markup.T
val markup_entity_def: Proof.context -> string -> Markup.T
val markup_fixed: Proof.context -> string -> Markup.T
val maxidx_of: Proof.context -> int
val maybe_bind_term:
indexname * term option -> Proof.context -> Proof.context
val names_of: Proof.context -> Name.context
val next_bound: string * typ -> Proof.context -> term * Proof.context
val polymorphic: Proof.context -> term list -> term list
val polymorphic_types:
Proof.context -> term list -> (indexname * sort) list * term list
val restore_body: Proof.context -> Proof.context -> Proof.context
val restore_bound_focus: Proof.context -> Proof.context -> Proof.context
val restore_proper_fixes: Proof.context -> Proof.context -> Proof.context
val revert_bounds: Proof.context -> term -> term
val revert_fixed: Proof.context -> string -> string
val set_body: bool -> Proof.context -> Proof.context
val set_bound_focus: bool -> Proof.context -> Proof.context
val trade:
(Proof.context -> thm list -> thm list) ->
Proof.context -> thm list -> thm list
val tradeT:
(Proof.context -> thm list -> thm list) ->
Proof.context -> thm list -> thm list
val unbind_term: indexname -> Proof.context -> Proof.context
val variant_fixes:
string list -> Proof.context -> string list * Proof.context
val variant_frees:
Proof.context -> term list -> (string * 'a) list -> (string * 'a) list
val warn_extra_tfrees: Proof.context -> Proof.context -> unit
end
Warning: Pattern is not exhaustive.
val ([x], ctxt') = ctxt |> ... ... |> add_fixes [...] ||> restore_body ctxt
At (line 490 of "variable.ML")
structure Variable: VARIABLE
val it = (): unit
infix 1 then_conv
infix 0 else_conv
signature BASIC_CONV =
sig
val else_conv: conv * conv -> conv
val then_conv: conv * conv -> conv
end
signature CONV =
sig
val abs_conv: (cterm * Proof.context -> conv) -> Proof.context -> conv
val all_conv: conv
val arg1_conv: conv -> conv
val arg_conv: conv -> conv
val binder_conv: (cterm * Proof.context -> conv) -> Proof.context -> conv
val binop_conv: conv -> conv
val bottom_conv: (Proof.context -> conv) -> Proof.context -> conv
val cache_conv: conv -> conv
val comb_conv: conv -> conv
val combination_conv: conv -> conv -> conv
val concl_conv: int -> conv -> conv
val else_conv: conv * conv -> conv
val every_conv: conv list -> conv
val fconv_rule: conv -> thm -> thm
val first_conv: conv list -> conv
val forall_conv: (cterm * Proof.context -> conv) -> Proof.context -> conv
val fun2_conv: conv -> conv
val fun_conv: conv -> conv
val gconv_rule: conv -> int -> thm -> thm
val implies_concl_conv: conv -> conv
val implies_conv: conv -> conv -> conv
val no_conv: conv
val params_conv: int -> (Proof.context -> conv) -> Proof.context -> conv
val prems_conv: int -> conv -> conv
val repeat_conv: conv -> conv
val rewr_conv: thm -> conv
val rewrs_conv: thm list -> conv
val sub_conv: (Proof.context -> conv) -> Proof.context -> conv
val then_conv: conv * conv -> conv
val top_conv: (Proof.context -> conv) -> Proof.context -> conv
val top_sweep_conv: (Proof.context -> conv) -> Proof.context -> conv
val try_conv: conv -> conv
end
structure Conv: CONV
structure Basic_Conv: BASIC_CONV
val else_conv = fn: conv * conv -> conv
val then_conv = fn: conv * conv -> conv
val it = (): unit
signature GOAL_DISPLAY =
sig
val goals_limit: int Config.T
val goals_limit_raw: Config.raw
val pretty_goal: Proof.context -> thm -> Pretty.T
val pretty_goals: Proof.context -> thm -> Pretty.T list
val show_main_goal: bool Config.T
val show_main_goal_raw: Config.raw
val string_of_goal: Proof.context -> thm -> string
end
structure Goal_Display: GOAL_DISPLAY
val it = (): unit
infix 1 THEN
infix 1 THEN'
infix 1 THEN_ALL_NEW
infix 0 ORELSE
infix 0 APPEND
infix 0 ORELSE'
infix 0 APPEND'
infix 0 THEN_ELSE
signature TACTICAL =
sig
val ALLGOALS: (int -> tactic) -> tactic
val APPEND: tactic * tactic -> tactic
val APPEND': ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val ASSERT_SUBGOAL: (int -> tactic) -> int -> tactic
val CHANGED: tactic -> tactic
val CHANGED_GOAL: (int -> tactic) -> int -> tactic
val CHANGED_PROP: tactic -> tactic
val COND: (thm -> bool) -> tactic -> tactic -> tactic
val CONVERSION: conv -> int -> tactic
val CSUBGOAL: (cterm * int -> tactic) -> int -> tactic
val DETERM: tactic -> tactic
val EVERY: tactic list -> tactic
val EVERY': ('a -> tactic) list -> 'a -> tactic
val EVERY1: (int -> tactic) list -> tactic
val FILTER: (thm -> bool) -> tactic -> tactic
val FIRST: tactic list -> tactic
val FIRST': ('a -> tactic) list -> 'a -> tactic
val FIRST1: (int -> tactic) list -> tactic
val FIRSTGOAL: (int -> tactic) -> tactic
val HEADGOAL: (int -> tactic) -> tactic
val ORELSE: tactic * tactic -> tactic
val ORELSE': ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val PRIMITIVE: (thm -> thm) -> tactic
val PRIMSEQ: (thm -> thm Seq.seq) -> tactic
val RANGE: (int -> tactic) list -> int -> tactic
val REPEAT: tactic -> tactic
val REPEAT1: tactic -> tactic
val REPEAT_ALL_NEW: (int -> tactic) -> int -> tactic
val REPEAT_DETERM: tactic -> tactic
val REPEAT_DETERM1: tactic -> tactic
val REPEAT_DETERM_FIRST: (int -> tactic) -> tactic
val REPEAT_DETERM_N: int -> tactic -> tactic
val REPEAT_DETERM_SOME: (int -> tactic) -> tactic
val REPEAT_FIRST: (int -> tactic) -> tactic
val REPEAT_SOME: (int -> tactic) -> tactic
val SINGLE: tactic -> thm -> thm option
val SOLVED': (int -> tactic) -> int -> tactic
val SOMEGOAL: (int -> tactic) -> tactic
val SUBGOAL: (term * int -> tactic) -> int -> tactic
val THEN: tactic * tactic -> tactic
val THEN': ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val THEN_ALL_NEW: (int -> tactic) * (int -> tactic) -> int -> tactic
val THEN_ELSE: tactic * (tactic * tactic) -> tactic
val TRY: tactic -> tactic
val TRYALL: (int -> tactic) -> tactic
val all_tac: tactic
val no_tac: tactic
val print_tac: Proof.context -> string -> tactic
type tactic = thm -> thm Seq.seq
end
Warning: Value identifier (st) has not been referenced.
At (line 117 of "tactical.ML")
structure Tactical: TACTICAL
type tactic = thm -> thm Seq.seq
val FILTER = fn: (thm -> bool) -> tactic -> tactic
val ASSERT_SUBGOAL = fn: (int -> tactic) -> int -> tactic
val TRYALL = fn: (int -> tactic) -> tactic
val THEN = fn: tactic * tactic -> tactic
val REPEAT = fn: tactic -> tactic
val COND = fn: (thm -> bool) -> tactic -> tactic -> tactic
val REPEAT1 = fn: tactic -> tactic
val REPEAT_SOME = fn: (int -> tactic) -> tactic
val ORELSE' = fn: ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val print_tac = fn: Proof.context -> string -> tactic
val REPEAT_DETERM1 = fn: tactic -> tactic
val CONVERSION = fn: conv -> int -> tactic
val EVERY = fn: tactic list -> tactic
val ORELSE = fn: tactic * tactic -> tactic
val FIRST = fn: tactic list -> tactic
val SOMEGOAL = fn: (int -> tactic) -> tactic
val REPEAT_FIRST = fn: (int -> tactic) -> tactic
val APPEND' = fn: ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val SINGLE = fn: tactic -> thm -> thm option
val SUBGOAL = fn: (term * int -> tactic) -> int -> tactic
val no_tac = fn: tactic
val ALLGOALS = fn: (int -> tactic) -> tactic
val THEN' = fn: ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val THEN_ELSE = fn: tactic * (tactic * tactic) -> tactic
val PRIMITIVE = fn: (thm -> thm) -> tactic
val REPEAT_ALL_NEW = fn: (int -> tactic) -> int -> tactic
val APPEND = fn: tactic * tactic -> tactic
val THEN_ALL_NEW = fn: (int -> tactic) * (int -> tactic) -> int -> tactic
val CSUBGOAL = fn: (cterm * int -> tactic) -> int -> tactic
val REPEAT_DETERM = fn: tactic -> tactic
val EVERY1 = fn: (int -> tactic) list -> tactic
val FIRSTGOAL = fn: (int -> tactic) -> tactic
val PRIMSEQ = fn: (thm -> thm Seq.seq) -> tactic
val REPEAT_DETERM_N = fn: int -> tactic -> tactic
val FIRST1 = fn: (int -> tactic) list -> tactic
val all_tac = fn: tactic
val CHANGED_GOAL = fn: (int -> tactic) -> int -> tactic
val HEADGOAL = fn: (int -> tactic) -> tactic
val TRY = fn: tactic -> tactic
val EVERY' = fn: ('a -> tactic) list -> 'a -> tactic
val RANGE = fn: (int -> tactic) list -> int -> tactic
val FIRST' = fn: ('a -> tactic) list -> 'a -> tactic
val CHANGED_PROP = fn: tactic -> tactic
val REPEAT_DETERM_SOME = fn: (int -> tactic) -> tactic
val SOLVED' = fn: (int -> tactic) -> int -> tactic
val REPEAT_DETERM_FIRST = fn: (int -> tactic) -> tactic
val DETERM = fn: tactic -> tactic
val CHANGED = fn: tactic -> tactic
val it = (): unit
infix 1 THEN_MAYBE
infix 1 THEN_MAYBE'
signature SEARCH =
sig
val ASTAR: (thm -> bool) * (int -> thm -> int) -> tactic -> tactic
val BEST_FIRST: (thm -> bool) * (thm -> int) -> tactic -> tactic
val BREADTH_FIRST: (thm -> bool) -> tactic -> tactic
val DEEPEN: int * int -> (int -> int -> tactic) -> int -> int -> tactic
val DEPTH_FIRST: (thm -> bool) -> tactic -> tactic
val DEPTH_SOLVE: tactic -> tactic
val DEPTH_SOLVE_1: tactic -> tactic
val IF_UNSOLVED: tactic -> tactic
val ITER_DEEPEN: int -> (thm -> bool) -> (int -> tactic) -> tactic
val QUIET_BREADTH_FIRST: (thm -> bool) -> tactic -> tactic
val SOLVE: tactic -> tactic
val THEN_ASTAR:
tactic -> (thm -> bool) * (int -> thm -> int) -> tactic -> tactic
val THEN_BEST_FIRST:
tactic -> (thm -> bool) * (thm -> int) -> tactic -> tactic
val THEN_ITER_DEEPEN:
int -> tactic -> (thm -> bool) -> (int -> tactic) -> tactic
val THEN_MAYBE: tactic * tactic -> tactic
val THEN_MAYBE': ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val has_fewer_prems: int -> thm -> bool
end
Warning: Value identifier (used) has not been referenced.
At (line 40 of "search.ML")
Warning: Value identifier (k') has not been referenced.
At (line 90 of "search.ML")
Warning: Value identifier (n) has not been referenced.
At (line 191 of "search.ML")
Warning: Value identifier (n) has not been referenced.
At (line 245 of "search.ML")
structure Search: SEARCH
val THEN_MAYBE' = fn: ('a -> tactic) * ('a -> tactic) -> 'a -> tactic
val DEPTH_SOLVE = fn: tactic -> tactic
val ITER_DEEPEN = fn: int -> (thm -> bool) -> (int -> tactic) -> tactic
val DEPTH_SOLVE_1 = fn: tactic -> tactic
val THEN_BEST_FIRST = fn:
tactic -> (thm -> bool) * (thm -> int) -> tactic -> tactic
val SOLVE = fn: tactic -> tactic
val THEN_MAYBE = fn: tactic * tactic -> tactic
val DEPTH_FIRST = fn: (thm -> bool) -> tactic -> tactic
val ASTAR = fn: (thm -> bool) * (int -> thm -> int) -> tactic -> tactic
val BEST_FIRST = fn: (thm -> bool) * (thm -> int) -> tactic -> tactic
val THEN_ASTAR = fn:
tactic -> (thm -> bool) * (int -> thm -> int) -> tactic -> tactic
val QUIET_BREADTH_FIRST = fn: (thm -> bool) -> tactic -> tactic
val DEEPEN = fn: int * int -> (int -> int -> tactic) -> int -> int -> tactic
val THEN_ITER_DEEPEN = fn:
int -> tactic -> (thm -> bool) -> (int -> tactic) -> tactic
val IF_UNSOLVED = fn: tactic -> tactic
val has_fewer_prems = fn: int -> thm -> bool
val BREADTH_FIRST = fn: (thm -> bool) -> tactic -> tactic
val it = (): unit
signature BASIC_TACTIC =
sig
val ares_tac: Proof.context -> thm list -> int -> tactic
val assume_tac: Proof.context -> int -> tactic
val bimatch_from_nets_tac:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val bimatch_tac: Proof.context -> (bool * thm) list -> int -> tactic
val biresolution_from_nets_tac:
Proof.context ->
('a list -> (bool * thm) list) ->
bool -> 'a Net.net * 'a Net.net -> int -> tactic
val biresolve0_tac: (bool * thm) list -> int -> tactic
val biresolve_from_nets_tac:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val biresolve_tac: Proof.context -> (bool * thm) list -> int -> tactic
val compose_tac: Proof.context -> bool * thm * int -> int -> tactic
val cut_facts_tac: thm list -> int -> tactic
val cut_rules_tac: thm list -> int -> tactic
val cut_tac: thm -> int -> tactic
val defer_tac: int -> tactic
val distinct_subgoal_tac: int -> tactic
val distinct_subgoals_tac: tactic
val dmatch_tac: Proof.context -> thm list -> int -> tactic
val dresolve0_tac: thm list -> int -> tactic
val dresolve_tac: Proof.context -> thm list -> int -> tactic
val ematch_tac: Proof.context -> thm list -> int -> tactic
val eq_assume_tac: int -> tactic
val eresolve0_tac: thm list -> int -> tactic
val eresolve_tac: Proof.context -> thm list -> int -> tactic
val filt_resolve_from_net_tac:
Proof.context -> int -> (int * thm) Net.net -> int -> tactic
val filter_prems_tac: Proof.context -> (term -> bool) -> int -> tactic
val filter_thms:
(term * term -> bool) -> int * term * thm list -> thm list
val flexflex_tac: Proof.context -> tactic
val forward_tac: Proof.context -> thm list -> int -> tactic
val lessb: (bool * thm) * (bool * thm) -> bool
val make_elim: thm -> thm
val match_from_net_tac:
Proof.context -> (int * thm) Net.net -> int -> tactic
val match_tac: Proof.context -> thm list -> int -> tactic
val prefer_tac: int -> tactic
val rename_tac: string list -> int -> tactic
val resolve0_tac: thm list -> int -> tactic
val resolve_from_net_tac:
Proof.context -> (int * thm) Net.net -> int -> tactic
val resolve_tac: Proof.context -> thm list -> int -> tactic
val rotate_tac: int -> int -> tactic
val rule_by_tactic: Proof.context -> tactic -> thm -> thm
val solve_tac: Proof.context -> thm list -> int -> tactic
val subgoals_of_brl: bool * thm -> int
val trace_goalno_tac: (int -> tactic) -> int -> tactic
end
signature TACTIC =
sig
val ares_tac: Proof.context -> thm list -> int -> tactic
val assume_tac: Proof.context -> int -> tactic
val bimatch_from_nets_tac:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val bimatch_tac: Proof.context -> (bool * thm) list -> int -> tactic
val biresolution_from_nets_tac:
Proof.context ->
('a list -> (bool * thm) list) ->
bool -> 'a Net.net * 'a Net.net -> int -> tactic
val biresolve0_tac: (bool * thm) list -> int -> tactic
val biresolve_from_nets_tac:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val biresolve_tac: Proof.context -> (bool * thm) list -> int -> tactic
val build_net: thm list -> (int * thm) Net.net
val compose_tac: Proof.context -> bool * thm * int -> int -> tactic
val cut_facts_tac: thm list -> int -> tactic
val cut_rules_tac: thm list -> int -> tactic
val cut_tac: thm -> int -> tactic
val defer_tac: int -> tactic
val delete_tagged_brl:
bool * thm ->
('a * (bool * thm)) Net.net * ('a * (bool * thm)) Net.net ->
('a * (bool * thm)) Net.net * ('a * (bool * thm)) Net.net
val distinct_subgoal_tac: int -> tactic
val distinct_subgoals_tac: tactic
val dmatch_tac: Proof.context -> thm list -> int -> tactic
val dresolve0_tac: thm list -> int -> tactic
val dresolve_tac: Proof.context -> thm list -> int -> tactic
val ematch_tac: Proof.context -> thm list -> int -> tactic
val eq_assume_tac: int -> tactic
val eq_kbrl: ('a * (bool * thm)) * ('a * (bool * thm)) -> bool
val eresolve0_tac: thm list -> int -> tactic
val eresolve_tac: Proof.context -> thm list -> int -> tactic
val filt_resolve_from_net_tac:
Proof.context -> int -> (int * thm) Net.net -> int -> tactic
val filter_prems_tac: Proof.context -> (term -> bool) -> int -> tactic
val filter_thms:
(term * term -> bool) -> int * term * thm list -> thm list
val flexflex_tac: Proof.context -> tactic
val forward_tac: Proof.context -> thm list -> int -> tactic
val insert_tagged_brl:
'a * (bool * thm) ->
('a * (bool * thm)) Net.net * ('a * (bool * thm)) Net.net ->
('a * (bool * thm)) Net.net * ('a * (bool * thm)) Net.net
val lessb: (bool * thm) * (bool * thm) -> bool
val make_elim: thm -> thm
val match_from_net_tac:
Proof.context -> (int * thm) Net.net -> int -> tactic
val match_tac: Proof.context -> thm list -> int -> tactic
val prefer_tac: int -> tactic
val rename_tac: string list -> int -> tactic
val resolve0_tac: thm list -> int -> tactic
val resolve_from_net_tac:
Proof.context -> (int * thm) Net.net -> int -> tactic
val resolve_tac: Proof.context -> thm list -> int -> tactic
val rotate_tac: int -> int -> tactic
val rule_by_tactic: Proof.context -> tactic -> thm -> thm
val solve_tac: Proof.context -> thm list -> int -> tactic
val subgoals_of_brl: bool * thm -> int
val trace_goalno_tac: (int -> tactic) -> int -> tactic
end
Warning: Pattern is not exhaustive.
val ((_, [...]), ctxt'') = Variable.import true [... ...] ctxt'
At (line 83 of "tactic.ML")
Warning: Value identifier (limit) has not been referenced.
At (line 192 of "tactic.ML")
Warning: Value identifier (k) has not been referenced.
At (line 205 of "tactic.ML")
Warning: Value identifier (k) has not been referenced.
At (line 244 of "tactic.ML")
Warning: Value identifier (i) has not been referenced.
At (line 289 of "tactic.ML")
structure Tactic: TACTIC
structure Basic_Tactic: BASIC_TACTIC
val eresolve0_tac = fn: thm list -> int -> tactic
val prefer_tac = fn: int -> tactic
val resolve_tac = fn: Proof.context -> thm list -> int -> tactic
val filt_resolve_from_net_tac = fn:
Proof.context -> int -> (int * thm) Net.net -> int -> tactic
val cut_facts_tac = fn: thm list -> int -> tactic
val eq_assume_tac = fn: int -> tactic
val dmatch_tac = fn: Proof.context -> thm list -> int -> tactic
val ematch_tac = fn: Proof.context -> thm list -> int -> tactic
val compose_tac = fn: Proof.context -> bool * thm * int -> int -> tactic
val match_tac = fn: Proof.context -> thm list -> int -> tactic
val make_elim = fn: thm -> thm
val biresolve0_tac = fn: (bool * thm) list -> int -> tactic
val cut_rules_tac = fn: thm list -> int -> tactic
val subgoals_of_brl = fn: bool * thm -> int
val ares_tac = fn: Proof.context -> thm list -> int -> tactic
val forward_tac = fn: Proof.context -> thm list -> int -> tactic
val biresolve_from_nets_tac = fn:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val cut_tac = fn: thm -> int -> tactic
val defer_tac = fn: int -> tactic
val distinct_subgoal_tac = fn: int -> tactic
val resolve0_tac = fn: thm list -> int -> tactic
val rotate_tac = fn: int -> int -> tactic
val trace_goalno_tac = fn: (int -> tactic) -> int -> tactic
val resolve_from_net_tac = fn:
Proof.context -> (int * thm) Net.net -> int -> tactic
val filter_prems_tac = fn: Proof.context -> (term -> bool) -> int -> tactic
val bimatch_from_nets_tac = fn:
Proof.context ->
(int * (bool * thm)) Net.net * (int * (bool * thm)) Net.net ->
int -> tactic
val bimatch_tac = fn: Proof.context -> (bool * thm) list -> int -> tactic
val assume_tac = fn: Proof.context -> int -> tactic
val match_from_net_tac = fn:
Proof.context -> (int * thm) Net.net -> int -> tactic
val flexflex_tac = fn: Proof.context -> tactic
val filter_thms = fn:
(term * term -> bool) -> int * term * thm list -> thm list
val distinct_subgoals_tac = fn: tactic
val biresolve_tac = fn: Proof.context -> (bool * thm) list -> int -> tactic
val rename_tac = fn: string list -> int -> tactic
val lessb = fn: (bool * thm) * (bool * thm) -> bool
val biresolution_from_nets_tac = fn:
Proof.context ->
('a list -> (bool * thm) list) ->
bool -> 'a Net.net * 'a Net.net -> int -> tactic
val dresolve_tac = fn: Proof.context -> thm list -> int -> tactic
val eresolve_tac = fn: Proof.context -> thm list -> int -> tactic
val rule_by_tactic = fn: Proof.context -> tactic -> thm -> thm
val solve_tac = fn: Proof.context -> thm list -> int -> tactic
val dresolve0_tac = fn: thm list -> int -> tactic
val it = (): unit
infix 4 addsimps
infix 4 delsimps
infix 4 addsimprocs
infix 4 delsimprocs
infix 4 setloop
infix 4 addloop
infix 4 delloop
infix 4 setSSolver
infix 4 addSSolver
infix 4 setSolver
infix 4 addSolver
signature BASIC_RAW_SIMPLIFIER =
sig
val addSSolver: Proof.context * solver -> Proof.context
val addSolver: Proof.context * solver -> Proof.context
val addloop:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val addsimprocs: Proof.context * simproc list -> Proof.context
val addsimps: Proof.context * thm list -> Proof.context
val cert_simproc:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option} ->
simproc
val clear_simpset: Proof.context -> Proof.context
type cong_name = bool * string
val delloop: Proof.context * string -> Proof.context
val delsimprocs: Proof.context * simproc list -> Proof.context
val delsimps: Proof.context * thm list -> Proof.context
val dest_ss:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val empty_simpset: Proof.context -> Proof.context
val empty_ss: simpset
val eq_rrule: rrule * rrule -> bool
val eq_simproc: simproc * simproc -> bool
val fold_goals_tac: Proof.context -> thm list -> tactic
val fold_rule: Proof.context -> thm list -> thm -> thm
val map_theory_simpset:
(Proof.context -> Proof.context) -> theory -> theory
val merge_ss: simpset * simpset -> simpset
val mk_rrules: Proof.context -> thm list -> rrule list
val mk_solver: string -> (Proof.context -> int -> tactic) -> solver
val norm_hhf: Proof.context -> thm -> thm
val norm_hhf_protect: Proof.context -> thm -> thm
type proc
val prune_params_tac: Proof.context -> tactic
val put_simpset: simpset -> Proof.context -> Proof.context
val rewrite_goal_tac: Proof.context -> thm list -> int -> tactic
val rewrite_goals_rule: Proof.context -> thm list -> thm -> thm
val rewrite_goals_tac: Proof.context -> thm list -> tactic
val rewrite_rule: Proof.context -> thm list -> thm -> thm
type rrule
val setSSolver: Proof.context * solver -> Proof.context
val setSolver: Proof.context * solver -> Proof.context
val setloop:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val simp_debug: bool Config.T
val simp_depth_limit: int Config.T
val simp_trace: bool Config.T
val simp_trace_depth_limit: int Config.T
type simproc
type simpset
val simpset_map:
Proof.context ->
(Proof.context -> Proof.context) -> simpset -> simpset
val simpset_of: Proof.context -> simpset
type solver
val transform_simproc: morphism -> simproc -> simproc
end
signature RAW_SIMPLIFIER =
sig
exception SIMPLIFIER of string * thm list
val addSSolver: Proof.context * solver -> Proof.context
val addSolver: Proof.context * solver -> Proof.context
val add_cong: thm -> Proof.context -> Proof.context
val add_eqcong: thm -> Proof.context -> Proof.context
val add_prems: thm list -> Proof.context -> Proof.context
val add_simp: thm -> Proof.context -> Proof.context
val addloop:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val addsimprocs: Proof.context * simproc list -> Proof.context
val addsimps: Proof.context * thm list -> Proof.context
val cert_simproc:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option} ->
simproc
val clear_simpset: Proof.context -> Proof.context
type cong_name = bool * string
val default_mk_sym: Proof.context -> thm -> thm option
val del_cong: thm -> Proof.context -> Proof.context
val del_eqcong: thm -> Proof.context -> Proof.context
val del_simp: thm -> Proof.context -> Proof.context
val delloop: Proof.context * string -> Proof.context
val delsimprocs: Proof.context * simproc list -> Proof.context
val delsimps: Proof.context * thm list -> Proof.context
val dest_ss:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val empty_simpset: Proof.context -> Proof.context
val empty_ss: simpset
val eq_rrule: rrule * rrule -> bool
val eq_simproc: simproc * simproc -> bool
val fold_goals_tac: Proof.context -> thm list -> tactic
val fold_rule: Proof.context -> thm list -> thm -> thm
val generic_rewrite_goal_tac:
bool * bool * bool ->
(Proof.context -> tactic) -> Proof.context -> int -> tactic
val init_simpset: thm list -> Proof.context -> Proof.context
val internal_ss:
simpset ->
{congs: (cong_name * thm) list * cong_name list,
loop_tacs: (string * (Proof.context -> int -> tactic)) list,
mk_rews:
{mk: Proof.context -> thm -> thm list,
mk_cong: Proof.context -> thm -> thm,
mk_eq_True: Proof.context -> thm -> thm option,
mk_sym: Proof.context -> thm -> thm option,
reorient: Proof.context -> term list -> term -> term -> bool},
procs: proc Net.net,
solvers: solver list * solver list,
subgoal_tac: Proof.context -> int -> tactic,
termless: term * term -> bool}
val map_ss:
(Proof.context -> Proof.context) -> Context.generic -> Context.generic
val map_theory_simpset:
(Proof.context -> Proof.context) -> theory -> theory
val merge_ss: simpset * simpset -> simpset
val mk_rrules: Proof.context -> thm list -> rrule list
val mk_solver: string -> (Proof.context -> int -> tactic) -> solver
val mksimps: Proof.context -> thm -> thm list
val norm_hhf: Proof.context -> thm -> thm
val norm_hhf_protect: Proof.context -> thm -> thm
val prems_of: Proof.context -> thm list
type proc
val prune_params_tac: Proof.context -> tactic
val put_simpset: simpset -> Proof.context -> Proof.context
val rewrite: Proof.context -> bool -> thm list -> conv
val rewrite_cterm:
bool * bool * bool ->
(Proof.context -> thm -> thm option) -> Proof.context -> conv
val rewrite_goal_tac: Proof.context -> thm list -> int -> tactic
val rewrite_goals_rule: Proof.context -> thm list -> thm -> thm
val rewrite_goals_tac: Proof.context -> thm list -> tactic
val rewrite_rule: Proof.context -> thm list -> thm -> thm
val rewrite_term:
theory -> thm list -> (term -> term option) list -> term -> term
val rewrite_thm:
bool * bool * bool ->
(Proof.context -> thm -> thm option) -> Proof.context -> thm -> thm
type rrule
val setSSolver: Proof.context * solver -> Proof.context
val setSolver: Proof.context * solver -> Proof.context
val set_mkcong:
(Proof.context -> thm -> thm) -> Proof.context -> Proof.context
val set_mkeqTrue:
(Proof.context -> thm -> thm option) -> Proof.context -> Proof.context
val set_mksimps:
(Proof.context -> thm -> thm list) -> Proof.context -> Proof.context
val set_mksym:
(Proof.context -> thm -> thm option) -> Proof.context -> Proof.context
val set_reorient:
(Proof.context -> term list -> term -> term -> bool) ->
Proof.context -> Proof.context
val set_solvers: solver list -> Proof.context -> Proof.context
val set_subgoaler:
(Proof.context -> int -> tactic) -> Proof.context -> Proof.context
val set_termless: (term * term -> bool) -> Proof.context -> Proof.context
val set_trace_ops: trace_ops -> theory -> theory
val setloop:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val simp_debug: bool Config.T
val simp_debug_raw: Config.raw
val simp_depth_limit: int Config.T
val simp_depth_limit_raw: Config.raw
val simp_trace: bool Config.T
val simp_trace_depth_limit: int Config.T
val simp_trace_depth_limit_raw: Config.raw
val simp_trace_raw: Config.raw
type simproc
type simpset
val simpset_map:
Proof.context ->
(Proof.context -> Proof.context) -> simpset -> simpset
val simpset_of: Proof.context -> simpset
val solver: Proof.context -> solver -> int -> tactic
type solver
type trace_ops
val transform_simproc: morphism -> simproc -> simproc
end
Warning: Pattern is not exhaustive.
val _ $ _ $ prop0 = Thm.prop_of thm
At (line 859 of "raw_simplifier.ML")
Warning: Pattern is not exhaustive.
val SOME thm'' = ... ... false eta_thm thm'
At (line 959 of "raw_simplifier.ML")
Warning: Matches are not exhaustive.
fun
botc skel ctxt ...
=
if is_Var skel then NONE else (case ... ... of ... => ... | ...)
and
try_botc ctxt ... = (case ... ... of ... => ... | ...) and
subc ... = let ... in ... end and
impc ... = ... and
... and
...
At (line 1202 of "raw_simplifier.ML")
Warning: Value identifier (k) has not been referenced.
At (line 1226 of "raw_simplifier.ML")
Warning: Matches are not exhaustive.
fun
botc skel ctxt ...
=
if is_Var skel then NONE else (case ... ... of ... => ... | ...)
and
try_botc ctxt ... = (case ... ... of ... => ... | ...) and
subc ... = let ... in ... end and
impc ... = ... and
... and
...
At (line 1226 of "raw_simplifier.ML")
structure Raw_Simplifier: RAW_SIMPLIFIER
structure Basic_Meta_Simplifier: BASIC_RAW_SIMPLIFIER
type simproc
type rrule =
{elhs: cterm,
extra: bool, fo: bool, lhs: term, name: string, perm: bool, thm: thm}
type solver
type cong_name = bool * string
type proc
type simpset
val rewrite_goals_rule = fn: Proof.context -> thm list -> thm -> thm
val rewrite_rule = fn: Proof.context -> thm list -> thm -> thm
val transform_simproc = fn: morphism -> simproc -> simproc
val setloop = fn:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val setSSolver = fn: Proof.context * solver -> Proof.context
val simpset_map = fn:
Proof.context -> (Proof.context -> Proof.context) -> simpset -> simpset
val empty_ss =
Simpset
({depth = (0, ref false), prems = [], rules = Leaf []},
{congs = ([], []), loop_tacs = [], mk_rews =
{mk = fn, mk_cong = fn, mk_eq_True = fn, mk_sym = fn, reorient = fn},
procs = Leaf [], solvers = ([], []), subgoal_tac = fn, termless = fn}):
simpset
val clear_simpset = fn: Proof.context -> Proof.context
val cert_simproc = fn:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option} -> simproc
val rewrite_goal_tac = fn: Proof.context -> thm list -> int -> tactic
val simpset_of = fn: Proof.context -> simpset
val simp_trace_depth_limit =
Config
{get_value = fn, map_value = fn, name = "simp_trace_depth_limit", pos =
{line=396, file=raw_simplifier.ML}}: int Config.T
val prune_params_tac = fn: Proof.context -> tactic
val map_theory_simpset = fn:
(Proof.context -> Proof.context) -> theory -> theory
val eq_simproc = fn: simproc * simproc -> bool
val empty_simpset = fn: Proof.context -> Proof.context
val simp_trace =
Config
{get_value = fn, map_value = fn, name = "simp_trace", pos =
{line=418, file=raw_simplifier.ML}}: bool Config.T
val norm_hhf = fn: Proof.context -> thm -> thm
val rewrite_goals_tac = fn: Proof.context -> thm list -> tactic
val mk_solver = fn: string -> (Proof.context -> int -> tactic) -> solver
val dest_ss = fn:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val addSolver = fn: Proof.context * solver -> Proof.context
val simp_depth_limit =
Config
{get_value = fn, map_value = fn, name = "simp_depth_limit", pos =
{line=392, file=raw_simplifier.ML}}: int Config.T
val put_simpset = fn: simpset -> Proof.context -> Proof.context
val merge_ss = fn: simpset * simpset -> simpset
val norm_hhf_protect = fn: Proof.context -> thm -> thm
val setSolver = fn: Proof.context * solver -> Proof.context
val addsimprocs = fn: Proof.context * simproc list -> Proof.context
val addsimps = fn: Proof.context * thm list -> Proof.context
val delsimprocs = fn: Proof.context * simproc list -> Proof.context
val delsimps = fn: Proof.context * thm list -> Proof.context
val simp_debug =
Config
{get_value = fn, map_value = fn, name = "simp_debug", pos =
{line=415, file=raw_simplifier.ML}}: bool Config.T
val fold_goals_tac = fn: Proof.context -> thm list -> tactic
val fold_rule = fn: Proof.context -> thm list -> thm -> thm
val addSSolver = fn: Proof.context * solver -> Proof.context
val addloop = fn:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val eq_rrule = fn: rrule * rrule -> bool
val mk_rrules = fn: Proof.context -> thm list -> rrule list
val delloop = fn: Proof.context * string -> Proof.context
val it = (): unit
signature CONJUNCTION =
sig
val cong: thm -> thm -> thm
val conjunction: cterm
val conjunctionD1: thm
val conjunctionD2: thm
val conjunctionI: thm
val convs: (cterm -> thm) -> cterm -> thm
val curry_balanced: int -> thm -> thm
val dest_conjunction: cterm -> cterm * cterm
val dest_conjunctions: cterm -> cterm list
val elim: thm -> thm * thm
val elim_balanced: int -> thm -> thm list
val elim_conjunctions: thm -> thm list
val intr: thm -> thm -> thm
val intr_balanced: thm list -> thm
val mk_conjunction: cterm * cterm -> cterm
val mk_conjunction_balanced: cterm list -> cterm
val uncurry_balanced: int -> thm -> thm
end
structure Conjunction: CONJUNCTION
val it = (): unit
signature ASSUMPTION =
sig
val add_assms:
export -> cterm list -> Proof.context -> thm list * Proof.context
val add_assumes: cterm list -> Proof.context -> thm list * Proof.context
val all_assms_of: Proof.context -> cterm list
val all_prems_of: Proof.context -> thm list
val assume: Proof.context -> cterm -> thm
val assume_export: export
val assume_hyps: cterm -> Proof.context -> thm * Proof.context
val export: bool -> Proof.context -> Proof.context -> thm -> thm
type export = bool -> cterm list -> (thm -> thm) * (term -> term)
val export_morphism: Proof.context -> Proof.context -> morphism
val export_term: Proof.context -> Proof.context -> term -> term
val local_assms_of: Proof.context -> Proof.context -> cterm list
val local_prems_of: Proof.context -> Proof.context -> thm list
val presume_export: export
end
structure Assumption: ASSUMPTION
val it = (): unit
val it = (): unit
signature ML_SYNTAX =
sig
val atomic: string -> string
val is_identifier: string -> bool
val is_reserved: string -> bool
val make_binding: string * Position.T -> string
val pretty_string: int -> string -> Pretty.T
val print_char: string -> string
val print_class: class -> string
val print_indexname: indexname -> string
val print_int: int -> string
val print_list: ('a -> string) -> 'a list -> string
val print_option: ('a -> string) -> 'a option -> string
val print_pair: ('a -> string) -> ('b -> string) -> 'a * 'b -> string
val print_position: Position.T -> string
val print_properties: Properties.T -> string
val print_range: Position.range -> string
val print_sort: sort -> string
val print_string: string -> string
val print_strings: string list -> string
val print_term: term -> string
val print_typ: typ -> string
val reserved: Name.context
val reserved_names: string list
end
Warning: Value identifier (f) has not been referenced.
At (line 59 of "ML/ml_syntax.ML")
structure ML_Syntax: ML_SYNTAX
val it = (): unit
signature ML_ENV =
sig
val SML_environment: bool Config.T
val add_breakpoints:
(serial * (bool ref * Thread_Position.T)) list -> unit
val add_name_space:
{SML: bool} -> ML_Name_Space.T -> Context.generic -> Context.generic
val check_functor: string -> unit
val context: ML_Compiler0.context
val forget_structure: string -> Context.generic -> Context.generic
val get_breakpoint:
Context.generic -> serial -> (bool ref * Position.T) option
val inherit: Context.generic -> Context.generic -> Context.generic
val init_bootstrap: Context.generic -> Context.generic
val make_name_space: {SML: bool, exchange: bool} -> ML_Name_Space.T
val name_space: ML_Name_Space.T
end
structure ML_Env: ML_ENV
val it = (): unit
signature ML_OPTIONS =
sig
val debugger: bool Config.T
val debugger_enabled: Context.generic option -> bool
val debugger_raw: Config.raw
val exception_debugger: bool Config.T
val exception_debugger_enabled: Context.generic option -> bool
val exception_debugger_raw: Config.raw
val exception_trace: bool Config.T
val exception_trace_enabled: Context.generic option -> bool
val exception_trace_raw: Config.raw
val source_trace: bool Config.T
val source_trace_raw: Config.raw
end
structure ML_Options: ML_OPTIONS
val it = (): unit
signature ML_PRINT_DEPTH =
sig
val get_print_depth: unit -> int
val print_depth: int Config.T
val print_depth_raw: Config.raw
val set_print_depth: int -> unit
end
structure ML_Print_Depth: ML_PRINT_DEPTH
val it = (): unit
signature EXN_DEBUGGER =
sig
val capture_exception_trace:
(unit -> 'a) ->
(string * ML_Compiler0.polyml_location) list * 'a Exn.result
end
structure Exn_Debugger: EXN_DEBUGGER
val it = (): unit
signature RUNTIME =
sig
exception EXCURSION_FAIL of exn * string
exception TOPLEVEL_ERROR
exception UNDEF
val controlled_execution:
Context.generic option -> ('a -> 'b) -> 'a -> 'b
val debugging: Context.generic option -> ('a -> 'b) -> 'a -> 'b
type error = (serial * string) * string option
val exn_context: Proof.context option -> exn -> exn
val exn_debugger: (unit -> 'a) -> 'a
val exn_debugger_system: (unit -> 'a) -> 'a
val exn_error_message: exn -> unit
val exn_message: exn -> string
val exn_message_list: exn -> string list
val exn_messages: exn -> error list
val exn_system_message: exn -> unit
val exn_trace: (unit -> 'a) -> 'a
val exn_trace_system: (unit -> 'a) -> 'a
val pretty_exn: exn -> Pretty.T
val thread_context: exn -> exn
val toplevel_error: (exn -> unit) -> ('a -> 'b) -> 'a -> 'b
val toplevel_program: (unit -> 'a) -> 'a
end
Warning: Handler catches all exceptions.
f x
handle
exn =>
if Exn.is_interrupt exn then Exn.reraise exn else
let val ... = ...; val ... in raise TOPLEVEL_ERROR end
At (line 200 of "Isar/runtime.ML")
structure Runtime: RUNTIME
val it = (): unit
signature EXECUTION =
sig
val cancel: int -> unit
val discontinue: unit -> unit
val fork: params -> (unit -> 'a) -> 'a future
val fork_prints: int -> unit
val is_running: int -> bool
val is_running_exec: int -> bool
val join: int list -> unit
type params = {name: string, pos: Position.T, pri: int}
val peek: int -> Task_Queue.group list
val print: params -> (unit -> unit) -> unit
val purge: int list -> unit
val reset: unit -> Task_Queue.group list
val running: int -> int -> Task_Queue.group list -> bool
val shutdown: unit -> unit
val snapshot: int list -> Task_Queue.task list
val start: unit -> int
end
structure Execution: EXECUTION
val it = (): unit
signature ML_COMPILER =
sig
val debug_flags: bool option -> flags
val eval: flags -> Position.T -> ML_Lex.token list -> unit
val flags: flags
type flags =
{SML: bool,
debug: bool option,
exchange: bool,
redirect: bool,
verbose: bool, warning: string -> unit, writeln: string -> unit}
val verbose: bool -> flags -> flags
end
Warning: Handler catches all exceptions.
(
while not (List.null (! input_buffer)) do
ML_Recursive.recursive env (fn () => ... ...))
handle
exn =>
if Exn.is_interrupt exn then Exn.reraise exn else
let val ... = ...; val ...; ... in raise_error exn_msg end
At (line 288 of "ML/ml_compiler.ML")
structure ML_Compiler: ML_COMPILER
val it = (): unit
signature SKIP_PROOF =
sig
val cheat_tac: Proof.context -> int -> tactic
val make_thm: theory -> term -> thm
val make_thm_cterm: cterm -> thm
val report: Proof.context -> unit
end
structure Skip_Proof: SKIP_PROOF
val it = (): unit
signature BASIC_GOAL =
sig
val CONJUNCTS: tactic -> int -> tactic
val PRECISE_CONJUNCTS: int -> tactic -> int -> tactic
val PREFER_GOAL: tactic -> int -> tactic
val SELECT_GOAL: tactic -> int -> tactic
val parallel_proofs: int ref
val quick_and_dirty: bool Config.T
end
signature GOAL =
sig
val CONJUNCTS: tactic -> int -> tactic
val PRECISE_CONJUNCTS: int -> tactic -> int -> tactic
val PREFER_GOAL: tactic -> int -> tactic
val SELECT_GOAL: tactic -> int -> tactic
val assume_rule_tac: Proof.context -> int -> tactic
val check_finished: Proof.context -> thm -> thm
val conclude: thm -> thm
val conjunction_tac: int -> tactic
val finish: Proof.context -> thm -> thm
val future_enabled: int -> bool
val future_enabled_timing: Time.time -> bool
val future_result: Proof.context -> thm future -> term -> thm
val init: cterm -> thm
val is_schematic: term -> bool
val norm_hhf_tac: Proof.context -> int -> tactic
val norm_result: Proof.context -> thm -> thm
val parallel_proofs: int ref
val precise_conjunction_tac: int -> int -> tactic
val protect: int -> thm -> thm
val prove:
Proof.context ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val prove_common:
Proof.context ->
int option ->
string list ->
term list ->
term list ->
({context: Proof.context, prems: thm list} -> tactic) ->
thm list
val prove_future:
Proof.context ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val prove_global:
theory ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val prove_global_future:
theory ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val prove_internal:
Proof.context -> cterm list -> cterm -> (thm list -> tactic) -> thm
val prove_sorry:
Proof.context ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val prove_sorry_global:
theory ->
string list ->
term list ->
term ->
({context: Proof.context, prems: thm list} -> tactic) -> thm
val quick_and_dirty: bool Config.T
val quick_and_dirty_raw: Config.raw
val recover_conjunction_tac: tactic
val restrict: int -> int -> thm -> thm
val skip_proofs_enabled: unit -> bool
val unrestrict: int -> thm -> thm
end
structure Goal: GOAL
structure Basic_Goal: BASIC_GOAL
val SELECT_GOAL = fn: tactic -> int -> tactic
val quick_and_dirty =
Config
{get_value = fn, map_value = fn, name = "quick_and_dirty", pos =
{line=258, file=goal.ML}}: bool Config.T
val CONJUNCTS = fn: tactic -> int -> tactic
val parallel_proofs = ref 1: int ref
val PREFER_GOAL = fn: tactic -> int -> tactic
val PRECISE_CONJUNCTS = fn: int -> tactic -> int -> tactic
val it = (): unit
signature KEYWORD =
sig
val add_keywords:
((string * Position.T) * spec) list -> keywords -> keywords
val before_command: string
val before_command_spec: spec
val command_files: keywords -> string -> Path.T -> Path.T list
val command_kind: keywords -> string -> string option
val command_markup: keywords -> string -> Markup.T option
val command_tags: keywords -> string -> string list
val dest_commands: keywords -> string list
val diag: string
val document_body: string
val document_heading: string
val document_raw: string
val empty_keywords: keywords
val is_command: keywords -> string -> bool
val is_diag: keywords -> string -> bool
val is_document: keywords -> string -> bool
val is_document_body: keywords -> string -> bool
val is_document_heading: keywords -> string -> bool
val is_document_raw: keywords -> string -> bool
val is_improper: keywords -> string -> bool
val is_keyword: keywords -> string -> bool
val is_literal: keywords -> string -> bool
val is_printed: keywords -> string -> bool
val is_proof: keywords -> string -> bool
val is_proof_asm: keywords -> string -> bool
val is_proof_body: keywords -> string -> bool
val is_proof_close: keywords -> string -> bool
val is_proof_goal: keywords -> string -> bool
val is_proof_open: keywords -> string -> bool
val is_qed: keywords -> string -> bool
val is_qed_global: keywords -> string -> bool
val is_theory: keywords -> string -> bool
val is_theory_body: keywords -> string -> bool
val is_theory_end: keywords -> string -> bool
val is_theory_goal: keywords -> string -> bool
val is_theory_load: keywords -> string -> bool
val is_vacuous: keywords -> string -> bool
type keywords
val major_keywords: keywords -> Scan.lexicon
val merge_keywords: keywords * keywords -> keywords
val minor_keywords: keywords -> Scan.lexicon
val next_block: string
val no_command_keywords: keywords -> keywords
val no_spec: spec
val prf_asm: string
val prf_asm_goal: string
val prf_block: string
val prf_chain: string
val prf_close: string
val prf_decl: string
val prf_goal: string
val prf_open: string
val prf_script: string
val prf_script_asm_goal: string
val prf_script_goal: string
val qed: string
val qed_block: string
val qed_global: string
val qed_script: string
val quasi_command: string
val quasi_command_spec: spec
type spec = (string * string list) * string list
val thy_begin: string
val thy_decl: string
val thy_decl_block: string
val thy_end: string
val thy_goal: string
val thy_load: string
end
structure Keyword: KEYWORD
val it = (): unit
signature TOKEN =
sig
type T
val args_of_src: src -> T list
val assign: value option -> T -> T
val check_src:
Proof.context ->
(Proof.context -> 'a Name_Space.table) -> src -> src * 'a
val checked_src: src -> bool
val closure: T -> T
val completion_report: T -> Position.report_text list
val content_of: T -> string
type 'a context_parser =
Context.generic * T list -> 'a * (Context.generic * T list)
val declare_maxidx: T -> Proof.context -> Proof.context
val eof: T
val evaluate: ('a -> value) -> (T -> 'a) -> T -> 'a
val explode: Keyword.keywords -> Position.T -> string -> T list
type file =
{digest: SHA1.digest,
lines: string list, pos: Position.T, src_path: Path.T}
val get_files: T -> file Exn.result list
val get_name: T -> name_value option
val get_value: T -> value option
val ident_or_symbolic: string -> bool
val ident_with: (string -> bool) -> T -> bool
val init_assignable: T -> T
val inner_syntax_of: T -> string
val input_of: T -> Input.source
val is_begin_ignore: T -> bool
val is_blank: T -> bool
val is_command: T -> bool
val is_command_modifier: T -> bool
val is_comment: T -> bool
val is_end_ignore: T -> bool
val is_eof: T -> bool
val is_error: T -> bool
val is_improper: T -> bool
val is_kind: kind -> T -> bool
val is_newline: T -> bool
val is_proper: T -> bool
val is_space: T -> bool
val keyword_markup: bool * Markup.T -> string -> Markup.T
val keyword_with: (string -> bool) -> T -> bool
datatype kind =
Alt_String
| Cartouche
| Command
| Comment
| EOF
| Error of string
| Float
| Ident
| Keyword
| Long_Ident
| Nat
| Space
| String
| Sym_Ident
| Type_Ident
| Type_Var
| Var
| Verbatim
val kind_of: T -> kind
val make: (int * int) * string -> Position.T -> T * Position.T
val make_int: int -> T list
val make_src: string * Position.T -> T list -> src
val make_string: string * Position.T -> T
val map_facts: (string option -> thm list -> thm list) -> T -> T
val markups: Keyword.keywords -> T -> Markup.T list
val name_of_src: src -> string * Position.T
val name_value: name_value -> value
type name_value =
{kind: string,
name: string, print: Proof.context -> Markup.T * xstring}
val not_eof: T -> bool
type 'a parser = T list -> 'a * T list
val pos_of: T -> Position.T
val pretty_src: Proof.context -> src -> Pretty.T
val pretty_value: Proof.context -> T -> Pretty.T
val print: T -> string
val print_name: Keyword.keywords -> string -> string
val put_files: file Exn.result list -> T -> T
val range_of: T list -> Position.range
val read_antiq:
Keyword.keywords -> 'a parser -> Symbol_Pos.T list * Position.T -> 'a
val read_cartouche: Symbol_Pos.T list -> T
val read_no_commands:
Keyword.keywords -> 'a parser -> Symbol_Pos.T list -> 'a list
val reports: Keyword.keywords -> T -> Position.report_text list
val reports_of_value: T -> Position.report list
val source:
Keyword.keywords ->
Position.T ->
(string, 'a) Source.source ->
(T,
(Symbol_Pos.T, Position.T * (string, 'a) Source.source)
Source.source) Source.source
val source':
bool ->
Keyword.keywords ->
(Symbol_Pos.T, 'a) Source.source ->
(T, (Symbol_Pos.T, 'a) Source.source) Source.source
val source_proper:
(T, 'a) Source.source -> (T, (T, 'a) Source.source) Source.source
val source_strict:
Keyword.keywords ->
Position.T ->
(string, 'a) Source.source ->
(T,
(Symbol_Pos.T, Position.T * (string, 'a) Source.source)
Source.source) Source.source
type src = T list
val stopper: T Scan.stopper
val str_of_kind: kind -> string
val syntax:
'a context_parser -> src -> Proof.context -> 'a * Proof.context
val syntax_generic:
'a context_parser -> src -> Context.generic -> 'a * Context.generic
val text_of: T -> string * string
val transform: morphism -> T -> T
val unparse: T -> string
datatype value =
Attribute of morphism -> attribute
| Declaration of declaration
| Fact of string option * thm list
| Files of file Exn.result list
| Literal of bool * Markup.T
| Name of name_value * morphism
| Source of src
| Term of term
| Typ of typ
end
structure Token: TOKEN
type 'a parser = 'a Token.parser
type 'a context_parser = 'a Token.context_parser
val it = (): unit
signature PARSE =
sig
val !!!: (Token.T list -> 'a) -> Token.T list -> 'a
val !!!!: (Token.T list -> 'a) -> Token.T list -> 'a
val $$$: string -> string parser
val ML_source: Input.source parser
val alt_string: string parser
val and_list: 'a parser -> 'a list parser
val and_list': 'a context_parser -> 'a list context_parser
val and_list1: 'a parser -> 'a list parser
val and_list1': 'a context_parser -> 'a list context_parser
val args: Token.T list parser
val args1: (string -> bool) -> Token.T list parser
val arity: (string * string list * string) parser
val attribs: Token.src list parser
val begin: string parser
val binding: binding parser
val cartouche: string parser
val class: string parser
val command: string -> string parser
val command_: string parser
val const: string parser
val const_binding: (binding * string * mixfix) parser
val const_decl: (string * string * mixfix) parser
val document_source: Input.source parser
val dots: string parser
val embedded: string parser
val enum: string -> 'a parser -> 'a list parser
val enum': string -> 'a context_parser -> 'a list context_parser
val enum1: string -> 'a parser -> 'a list parser
val enum1': string -> 'a context_parser -> 'a list context_parser
val enum1_positions:
string -> 'a parser -> ('a list * Position.T list) parser
val enum_positions:
string -> 'a parser -> ('a list * Position.T list) parser
val eof: string parser
val float_number: string parser
val for_fixes: (binding * string option * mixfix) list parser
val group: (unit -> string) -> (Token.T list -> 'a) -> Token.T list -> 'a
val inner_syntax: 'a parser -> string parser
val input: 'a parser -> Input.source parser
val int: int parser
val keyword: string parser
val keyword_improper: string -> string parser
val keyword_markup: bool * Markup.T -> string -> string parser
val keyword_with: (string -> bool) -> string parser
val liberal_name: string parser
val list: 'a parser -> 'a list parser
val list1: 'a parser -> 'a list parser
val literal_fact: string parser
val long_ident: string parser
val maybe: 'a parser -> 'a option parser
val minus: string parser
val mixfix: mixfix parser
val mixfix': mixfix parser
val multi_arity: (string list * string list * string) parser
val name: string parser
val nat: int parser
val not_eof: Token.T parser
val number: string parser
val opt_attribs: Token.src list parser
val opt_bang: bool parser
val opt_begin: bool parser
val opt_keyword: string -> bool parser
val opt_mixfix: mixfix parser
val opt_mixfix': mixfix parser
val opt_target: (string * Position.T) option parser
val params: (binding * string option * mixfix) list parser
val parbinding: binding parser
val parname: string parser
val path: string parser
val position: 'a parser -> ('a * Position.T) parser
val private: Position.T parser
val prop: string parser
val properties: Properties.T parser
val propp: (string * string list) parser
val qualified: Position.T parser
val range: 'a parser -> ('a * Position.range) parser
val real: real parser
val reserved: string -> string parser
val short_ident: string parser
val sort: string parser
val string: string parser
val sym_ident: string parser
val syntax_mode: Syntax.mode parser
val tag_name: string parser
val tags: string list parser
val target: (string * Position.T) parser
val term: string parser
val term_var: string parser
val termp: (string * string list) parser
val text: string parser
val theory_name: string parser
val thm: (Facts.ref * Token.src list) parser
val thm_sel: Facts.interval list parser
val thms1: (Facts.ref * Token.src list) list parser
val token: 'a parser -> Token.T parser
val typ: string parser
val type_args: string list parser
val type_args_constrained: (string * string option) list parser
val type_const: string parser
val type_ident: string parser
val type_var: string parser
val underscore: string parser
val vars: (binding * string option * mixfix) list parser
val verbatim: string parser
val where_: string parser
end
structure Parse: PARSE
val it = (): unit
signature THY_HEADER =
sig
val add_keywords: keywords -> theory -> theory
val args: header parser
val bootstrap_keywords: Keyword.keywords
val bootstrap_thys: string list
val get_keywords: theory -> Keyword.keywords
val get_keywords': Proof.context -> Keyword.keywords
type header =
{imports: (string * Position.T) list,
keywords: keywords, name: string * Position.T}
val import_name: string -> string
type keywords = ((string * Position.T) * Keyword.spec) list
val make:
string * Position.T ->
(string * Position.T) list -> keywords -> header
val ml_bootstrapN: string
val ml_roots: string list
val read: Position.T -> string -> header
val read_tokens: Token.T list -> header
val theoryN: string
end
structure Thy_Header: THY_HEADER
val it = (): unit
signature OBJECT_LOGIC =
sig
val add_base_sort: sort -> theory -> theory
val add_judgment: binding * typ * mixfix -> theory -> theory
val add_judgment_cmd: binding * string * mixfix -> theory -> theory
val atomize: Proof.context -> conv
val atomize_prems: Proof.context -> conv
val atomize_prems_tac: Proof.context -> int -> tactic
val atomize_term: Proof.context -> term -> term
val declare_atomize: attribute
val declare_rulify: attribute
val dest_judgment: Proof.context -> cterm -> cterm
val drop_judgment: Proof.context -> term -> term
val elim_concl: Proof.context -> thm -> term option
val ensure_propT: Proof.context -> term -> term
val fixed_judgment: Proof.context -> string -> term
val full_atomize_tac: Proof.context -> int -> tactic
val get_base_sort: Proof.context -> sort option
val is_judgment: Proof.context -> term -> bool
val judgment_conv: Proof.context -> conv -> conv
val judgment_name: Proof.context -> string
val rule_format: attribute
val rule_format_no_asm: attribute
val rulify: Proof.context -> thm -> thm
val rulify_no_asm: Proof.context -> thm -> thm
val rulify_tac: Proof.context -> int -> tactic
val rulify_term: Proof.context -> term -> term
end
structure Object_Logic: OBJECT_LOGIC
val it = (): unit
signature RULE_CASES =
sig
datatype T =
Case of
{assumes: (string * term list) list,
binds: (indexname * term option) list,
cases: (string * T) list, fixes: (binding * typ) list}
val add_consumes: int -> thm -> thm
val apply: term list -> T -> T
val case_conclN: string
val case_conclusion: string * string list -> attribute
val case_hypsN: string
val case_names: string list -> attribute
val case_premsN: string
type cases = (string * T option) list
val cases_hyp_names: string list -> string list list -> attribute
val cases_open: attribute
val constraints: int -> attribute
val consume:
Proof.context ->
thm list ->
thm list ->
('a * int) * thm -> (('a * (int * thm list)) * thm) Seq.seq
val consumes: int -> attribute
val default_consumes: int -> thm -> thm
val get: thm -> info * int
val get_constraints: thm -> int
val get_consumes: thm -> int
type info = ((string * string list) * string list) list
val inner_rule: attribute
val internalize_params: thm -> thm
val is_cases_open: thm -> bool
val is_inner_rule: thm -> bool
val make_common: Proof.context -> term -> info -> cases
val make_nested: Proof.context -> term -> term -> info -> cases
val mutual_rule: Proof.context -> thm list -> (int list * thm) option
val name: string list -> thm -> thm
val params: string list list -> attribute
val put_consumes: int option -> thm -> thm
val rename_params: string list list -> thm -> thm
val save: thm -> thm -> thm
val strict_mutual_rule: Proof.context -> thm list -> int list * thm
val strip_params: term -> (string * typ) list
end
Warning: Matches are not exhaustive.
fun extract ((...) :: rest) = (hyp_name, ... :: ...)
At (line 92 of "Isar/rule_cases.ML")
Warning: Pattern is not exhaustive.
val rules as (prems, ...) :: _ = map (prep_rule (... ...)) ths'
At (line 434 of "Isar/rule_cases.ML")
structure Rule_Cases: RULE_CASES
val it = (): unit
signature AUTO_BIND =
sig
val abs_params: term -> term -> term
val assmsN: string
val dddot: indexname
val facts: Proof.context -> term list -> (indexname * term option) list
val goal: Proof.context -> term list -> (indexname * term option) list
val no_facts: indexname list
val thatN: string
val thesisN: string
val thisN: string
end
structure Auto_Bind: AUTO_BIND
val it = (): unit
signature TYPE_INFER =
sig
val anyT: sort -> typ
val deref: typ Vartab.table -> typ -> typ
val finish:
Proof.context ->
typ Vartab.table -> typ list * term list -> typ list * term list
val fixate: Proof.context -> bool -> term list -> term list
val is_param: indexname -> bool
val is_paramT: typ -> bool
val mk_param: int -> sort -> typ
val object_logic: bool Config.T
val param: int -> string * sort -> typ
val param_maxidx: term -> int -> int
val param_maxidx_of: term list -> int
val paramify_vars: typ -> typ
end
Warning: Pattern is not exhaustive.
val [a] = Name.invent used Name.aT 1
At (line 116 of "type_infer.ML")
structure Type_Infer: TYPE_INFER
val it = (): unit
signature LOCAL_SYNTAX =
sig
type T
val add_syntax:
Proof.context ->
(kind * (string * typ * mixfix)) list ->
T -> {fixes: string list, structs: string list} option * T
val init: theory -> T
datatype kind = Const | Fixed | Type
val rebuild: theory -> T -> T
val restore_mode: T -> T -> T
val set_mode: Syntax.mode -> T -> T
val syn_of: T -> Syntax.syntax
val update_modesyntax:
Proof.context ->
bool ->
Syntax.mode ->
(kind * (string * typ * mixfix)) list ->
T -> {fixes: string list, structs: string list} option * T
end
structure Local_Syntax: LOCAL_SYNTAX
val it = (): unit
signature PROOF_CONTEXT =
sig
val abbrev_mode: Proof.context -> bool
val add_abbrev:
string ->
binding * term -> Proof.context -> (term * term) * Proof.context
val add_assms:
Assumption.export ->
(Thm.binding * (term * term list) list) list ->
Proof.context -> (string * thm list) list * Proof.context
val add_assms_cmd:
Assumption.export ->
(Thm.binding * (string * string list) list) list ->
Proof.context -> (string * thm list) list * Proof.context
val add_const_constraint:
string * typ option -> Proof.context -> Proof.context
val add_fixes:
(binding * typ option * mixfix) list ->
Proof.context -> string list * Proof.context
val add_fixes_cmd:
(binding * string option * mixfix) list ->
Proof.context -> string list * Proof.context
val add_thms_dynamic:
binding * (Context.generic -> thm list) ->
Proof.context -> string * Proof.context
val alias_fact: binding -> string -> Proof.context -> Proof.context
val allow_dummies: Proof.context -> Proof.context
val apply_case:
Rule_Cases.T ->
Proof.context -> (string * term list) list * Proof.context
val arity_sorts: Proof.context -> string -> sort -> sort list
val auto_bind_facts: term list -> Proof.context -> Proof.context
val auto_bind_goal: term list -> Proof.context -> Proof.context
val background_theory:
(theory -> theory) -> Proof.context -> Proof.context
val background_theory_result:
(theory -> 'a * theory) -> Proof.context -> 'a * Proof.context
val cert_arity: Proof.context -> arity -> arity
val cert_prop: Proof.context -> term -> term
val cert_propp:
Proof.context ->
(term * term list) list list ->
term list list * (indexname * term) list
val cert_statement:
(binding * typ option * mixfix) list ->
(term * term list) list list ->
(term * term list) list list ->
Proof.context ->
((string * term) list * term list list * term list list *
(indexname * term option) list) * Proof.context
val cert_stmt:
(binding * typ option * mixfix) list ->
(term * term list) list list ->
Proof.context ->
(((binding * typ option * mixfix) * (string * term)) list *
term list list * (indexname * term) list *
(indexname * term) list) * Proof.context
val cert_term: Proof.context -> term -> term
val cert_typ: Proof.context -> typ -> typ
val cert_typ_abbrev: Proof.context -> typ -> typ
val cert_typ_syntax: Proof.context -> typ -> typ
val cert_var:
binding * typ option * mixfix ->
Proof.context -> (binding * typ option * mixfix) * Proof.context
val check_case:
Proof.context ->
bool -> string * Position.T -> binding option list -> Rule_Cases.T
val check_class:
Proof.context -> xstring * Position.T -> class * Position.report list
val check_const:
{proper: bool, strict: bool} ->
Proof.context ->
xstring * Position.T list -> term * Position.report list
val check_tfree: Proof.context -> string * sort -> string * sort
val check_type_name:
{proper: bool, strict: bool} ->
Proof.context -> xstring * Position.T -> typ * Position.report list
val class_space: Proof.context -> Name_Space.T
val concealed: Proof.context -> Proof.context
val const_alias: binding -> string -> Proof.context -> Proof.context
val const_space: Proof.context -> Name_Space.T
val consts_completion_message:
Proof.context -> xstring * Position.T list -> string
val consts_of: Proof.context -> Consts.T
val debug: bool Config.T
val def_type: Proof.context -> indexname -> typ option
val default_sort: Proof.context -> indexname -> sort
val defs_context: Proof.context -> Defs.context
val dest_cases:
Proof.context option ->
Proof.context -> (string * (Rule_Cases.T * {legacy: bool})) list
val dynamic_facts_dummy: bool Config.T
val expand_abbrevs: Proof.context -> term -> term
val export: Proof.context -> Proof.context -> thm list -> thm list
val export_morphism: Proof.context -> Proof.context -> morphism
val extern_class: Proof.context -> string -> xstring
val extern_const: Proof.context -> string -> xstring
val extern_type: Proof.context -> string -> xstring
val fact_tac: Proof.context -> thm list -> int -> tactic
val facts_of: Proof.context -> Facts.T
val facts_of_fact: Proof.context -> string -> Facts.T
val full_name: Proof.context -> binding -> string
val generic_add_abbrev:
string ->
binding * term -> Context.generic -> (term * term) * Context.generic
val generic_notation:
bool ->
Syntax.mode ->
(term * mixfix) list ->
morphism -> Context.generic -> Context.generic
val generic_revert_abbrev:
string -> string -> Context.generic -> Context.generic
val generic_type_notation:
bool ->
Syntax.mode ->
(typ * mixfix) list ->
morphism -> Context.generic -> Context.generic
val get_fact: Proof.context -> Facts.ref -> thm list
val get_fact_generic:
Context.generic -> Facts.ref -> string option * thm list
val get_fact_single: Proof.context -> Facts.ref -> thm
val get_global: theory -> string -> Proof.context
val get_mode: Proof.context -> mode
val get_scope: Proof.context -> Binding.scope option
val get_thm: Proof.context -> xstring -> thm
val get_thms: Proof.context -> xstring -> thm list
val goal_export: Proof.context -> Proof.context -> thm list -> thm list
val infer_type: Proof.context -> string * typ -> typ
val inferred_fixes: Proof.context -> (string * typ) list * Proof.context
val inferred_param:
string -> Proof.context -> (string * typ) * Proof.context
val init_global: theory -> Proof.context
val intern_class: Proof.context -> xstring -> string
val intern_const: Proof.context -> xstring -> string
val intern_type: Proof.context -> xstring -> string
val lookup_fact:
Proof.context -> string -> {dynamic: bool, thms: thm list} option
val map_naming:
(Name_Space.naming -> Name_Space.naming) ->
Proof.context -> Proof.context
val markup_class: Proof.context -> string -> string
val markup_const: Proof.context -> string -> string
val markup_extern_fact:
Proof.context -> string -> Markup.T list * xstring
val markup_type: Proof.context -> string -> string
val match_bind:
bool ->
(term list * term) list ->
Proof.context -> term list * Proof.context
val match_bind_cmd:
bool ->
(string list * string) list ->
Proof.context -> term list * Proof.context
type mode
val mode_abbrev: mode
val mode_default: mode
val mode_pattern: mode
val mode_schematic: mode
val naming_of: Proof.context -> Name_Space.naming
val new_scope: Proof.context -> Binding.scope * Proof.context
val norm_export_morphism: Proof.context -> Proof.context -> morphism
val notation:
bool ->
Syntax.mode ->
(term * mixfix) list -> Proof.context -> Proof.context
val note_thmss:
string ->
(Thm.binding * (thm list * attribute list) list) list ->
Proof.context -> (string * thm list) list * Proof.context
val prepare_sorts: Proof.context -> term list -> string list * term list
val prepare_sortsT: Proof.context -> typ list -> string list * typ list
val pretty_cases: Proof.context -> Pretty.T list
val pretty_class: Proof.context -> string -> Pretty.T
val pretty_const: Proof.context -> string -> Pretty.T
val pretty_context: Proof.context -> Pretty.T list
val pretty_ctxt: Proof.context -> Pretty.T list
val pretty_fact: Proof.context -> string * thm list -> Pretty.T
val pretty_local_facts: bool -> Proof.context -> Pretty.T list
val pretty_name: Proof.context -> string -> Pretty.T
val pretty_term_abbrev: Proof.context -> term -> Pretty.T
val pretty_term_bindings: Proof.context -> Pretty.T list
val pretty_type: Proof.context -> string -> Pretty.T
val print_abbrevs: bool -> Proof.context -> unit
val print_cases_proof: Proof.context -> Proof.context -> string
val print_local_facts: bool -> Proof.context -> unit
val print_name: Proof.context -> string -> string
val print_syntax: Proof.context -> unit
val private: Position.T -> Proof.context -> Proof.context
val private_scope: Binding.scope -> Proof.context -> Proof.context
val put_thms:
bool -> string * thm list option -> Proof.context -> Proof.context
val qualified: Position.T -> Proof.context -> Proof.context
val qualified_scope: Binding.scope -> Proof.context -> Proof.context
val read_arity: Proof.context -> xstring * string list * string -> arity
val read_class: Proof.context -> string -> class
val read_const:
{proper: bool, strict: bool} -> Proof.context -> string -> term
val read_propp:
Proof.context ->
(string * string list) list list ->
term list list * (indexname * term) list
val read_statement:
(binding * string option * mixfix) list ->
(string * string list) list list ->
(string * string list) list list ->
Proof.context ->
((string * term) list * term list list * term list list *
(indexname * term option) list) * Proof.context
val read_stmt:
(binding * string option * mixfix) list ->
(string * string list) list list ->
Proof.context ->
(((binding * typ option * mixfix) * (string * term)) list *
term list list * (indexname * term) list *
(indexname * term) list) * Proof.context
val read_term_abbrev: Proof.context -> string -> term
val read_term_pattern: Proof.context -> string -> term
val read_term_schematic: Proof.context -> string -> term
val read_typ: Proof.context -> string -> typ
val read_typ_abbrev: Proof.context -> string -> typ
val read_typ_syntax: Proof.context -> string -> typ
val read_type_name:
{proper: bool, strict: bool} -> Proof.context -> string -> typ
val read_var:
binding * string option * mixfix ->
Proof.context -> (binding * typ option * mixfix) * Proof.context
val restore_mode: Proof.context -> Proof.context -> Proof.context
val restore_naming: Proof.context -> Proof.context -> Proof.context
val restore_stmt: Proof.context -> Proof.context -> Proof.context
val restore_syntax_mode: Proof.context -> Proof.context -> Proof.context
val revert_abbrev: string -> string -> Proof.context -> Proof.context
val set_defsort: sort -> Proof.context -> Proof.context
val set_mode: mode -> Proof.context -> Proof.context
val set_stmt: bool -> Proof.context -> Proof.context
val set_syntax_mode: Syntax.mode -> Proof.context -> Proof.context
val show_abbrevs: bool Config.T
val show_abbrevs_raw: Config.raw
val some_fact_tac: Proof.context -> int -> tactic
val standard_term_check_finish: Proof.context -> term list -> term list
val standard_term_uncheck: Proof.context -> term list -> term list
val standard_typ_check: Proof.context -> typ list -> typ list
val syn_of: Proof.context -> Syntax.syntax
val theory_of: Proof.context -> theory
val transfer: theory -> Proof.context -> Proof.context
val transfer_facts: theory -> Proof.context -> Proof.context
val tsig_of: Proof.context -> Type.tsig
val type_alias: binding -> string -> Proof.context -> Proof.context
val type_notation:
bool ->
Syntax.mode -> (typ * mixfix) list -> Proof.context -> Proof.context
val type_space: Proof.context -> Name_Space.T
val update_cases:
(string * Rule_Cases.T option) list -> Proof.context -> Proof.context
val update_cases_legacy:
(string * Rule_Cases.T option) list -> Proof.context -> Proof.context
val verbose: bool Config.T
end
Warning: Pattern is not exhaustive.
val (sorting_report, [... ...]) = prepare_sortsT ctxt [TFree v]
At (line 781 of "Isar/proof_context.ML")
Warning: Pattern is not exhaustive.
val ([x], ctxt') = Variable.add_fixes_binding [... ...] ctxt
At (line 1119 of "Isar/proof_context.ML")
Warning: Pattern is not exhaustive.
val [t] = Variable.exportT_terms (... ...) ctxt [t0]
At (line 1205 of "Isar/proof_context.ML")
Warning: Pattern is not exhaustive.
val ([x], ctxt') = add_fixes [(...)] ctxt
At (line 1318 of "Isar/proof_context.ML")
structure Proof_Context: PROOF_CONTEXT
val show_abbrevs =
Config
{get_value = fn, map_value = fn, name = "show_abbrevs", pos =
{line=635, file=Isar/proof_context.ML}}: bool Config.T
val it = (): unit
signature TYPE_INFER_CONTEXT =
sig
val const_sorts: bool Config.T
val const_type: Proof.context -> string -> typ option
val infer_types: Proof.context -> term list -> term list
val prepare: Proof.context -> term list -> int * term list
val prepare_positions:
Proof.context -> term list -> term list * (Position.T * typ) list
end
Warning: Pattern is not exhaustive.
val ([t', u'], [T', ...]) = ... ... bs [t, ...] [T, U]
At (line 259 of "type_infer_context.ML")
structure Type_Infer_Context: TYPE_INFER_CONTEXT
val it = (): unit
Warning: Pattern is not exhaustive.
val
(Type (c, ...), rs) =
Proof_Context.check_type_name {...} ctxt
(Lexicon.str_of_token tok, pos)
At (line 188 of "Syntax/syntax_phases.ML")
Warning: Pattern is not exhaustive.
val
(Const (c', ...), reports) = Proof_Context.check_const {...} ctxt (c, ps)
At (line 242 of "Syntax/syntax_phases.ML")
Warning: Matches are not exhaustive.
fun classes [c] = class c | classes (... :: ...) = ... $ ... $ ... ...
At (line 500 of "Syntax/syntax_phases.ML")
signature SYNTAX_PHASES =
sig
val decode_sort: term -> sort
val decode_term:
Proof.context ->
Position.report_text list * term Exn.result ->
Position.report_text list * term Exn.result
val decode_typ: term -> typ
val parse_ast_pattern: Proof.context -> string * string -> Ast.ast
val print_checks: Proof.context -> unit
val reports_of_scope: Position.T list -> Position.report list
val term_check:
int ->
string ->
(Proof.context -> term list -> term list) ->
Context.generic -> Context.generic
val term_check':
int ->
string ->
(term list -> Proof.context -> (term list * Proof.context) option)
-> Context.generic -> Context.generic
val term_of_typ: Proof.context -> typ -> term
val term_uncheck:
int ->
string ->
(Proof.context -> term list -> term list) ->
Context.generic -> Context.generic
val term_uncheck':
int ->
string ->
(term list -> Proof.context -> (term list * Proof.context) option)
-> Context.generic -> Context.generic
val typ_check:
int ->
string ->
(Proof.context -> typ list -> typ list) ->
Context.generic -> Context.generic
val typ_check':
int ->
string ->
(typ list -> Proof.context -> (typ list * Proof.context) option)
-> Context.generic -> Context.generic
val typ_uncheck:
int ->
string ->
(Proof.context -> typ list -> typ list) ->
Context.generic -> Context.generic
val typ_uncheck':
int ->
string ->
(typ list -> Proof.context -> (typ list * Proof.context) option)
-> Context.generic -> Context.generic
end
structure Syntax_Phases: SYNTAX_PHASES
val it = (): unit
signature ARGS =
sig
val $$$: string -> string parser
val add: string parser
val alt_name: string parser
val bang: string parser
val bang_colon: string parser
val binding: binding parser
val bracks: 'a parser -> 'a parser
val cartouche_declaration:
(Input.source -> declaration) -> declaration parser
val cartouche_inner_syntax: string parser
val cartouche_input: Input.source parser
val colon: string parser
val const: {proper: bool, strict: bool} -> string context_parser
val context: Proof.context context_parser
val del: string parser
val embedded: string parser
val embedded_inner_syntax: string parser
val embedded_input: Input.source parser
val embedded_token: Token.T parser
val goal_spec: ((int -> tactic) -> tactic) context_parser
val internal_attribute: (morphism -> attribute) parser
val internal_declaration: declaration parser
val internal_fact: thm list parser
val internal_name: Token.name_value parser
val internal_source: Token.src parser
val internal_term: term parser
val internal_typ: typ parser
val liberal_name: string parser
val maybe: 'a parser -> 'a option parser
val mode: string -> bool parser
val name: string parser
val name_token: Token.T parser
val named_attribute:
(string * Position.T -> morphism -> attribute) ->
(morphism -> attribute) parser
val named_fact: (string -> string option * thm list) -> thm list parser
val named_source: (Token.T -> Token.src) -> Token.src parser
val named_term: (string -> term) -> term parser
val named_typ: (string -> typ) -> typ parser
val parens: 'a parser -> 'a parser
val prop: term context_parser
val query: string parser
val query_colon: string parser
val symbolic: Token.T parser
val term: term context_parser
val term_abbrev: term context_parser
val term_pattern: term context_parser
val text: string parser
val text_declaration: (Input.source -> declaration) -> declaration parser
val text_input: Input.source parser
val text_token: Token.T parser
val theory: theory context_parser
val typ: typ context_parser
val typ_abbrev: typ context_parser
val type_name: {proper: bool, strict: bool} -> string context_parser
val var: indexname parser
end
Warning: Matches are not exhaustive.
fn Token.Source src => src
At (line 138 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Name (a, _) => a
At (line 139 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Typ T => T
At (line 140 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Term t => t
At (line 141 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Fact (_, ths) => ths
At (line 142 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Attribute att => att
At (line 143 of "Isar/args.ML")
Warning: Matches are not exhaustive.
fn Token.Declaration decl => decl
At (line 144 of "Isar/args.ML")
structure Args: ARGS
val it = (): unit
signature LOCAL_DEFS =
sig
val abs_def: term -> (string * typ) * term
val abs_def_rule: Proof.context -> thm -> thm
val cert_def:
Proof.context ->
(string -> Position.T list) -> term -> (string * typ) * term
val contract: Proof.context -> thm list -> cterm -> thm -> thm
val def_export: Assumption.export
val define:
((binding * mixfix) * (Thm.binding * term)) list ->
Proof.context -> (term * (string * thm)) list * Proof.context
val defn_add: attribute
val defn_del: attribute
val derived_def:
Proof.context ->
(string -> Position.T list) ->
{conditional: bool} ->
term -> ((string * typ) * term) * (Proof.context -> thm -> thm)
val expand: cterm list -> thm -> thm
val export:
Proof.context -> Proof.context -> thm -> (thm list * thm list) * thm
val export_cterm:
Proof.context ->
Proof.context -> cterm -> (thm list * thm list) * cterm
val fixed_abbrev:
(binding * mixfix) * term ->
Proof.context -> (term * term) * Proof.context
val fold: Proof.context -> thm list -> thm -> thm
val fold_tac: Proof.context -> thm list -> tactic
val meta_rewrite_conv: Proof.context -> conv
val meta_rewrite_rule: Proof.context -> thm -> thm
val print_rules: Proof.context -> unit
val unfold: Proof.context -> thm list -> thm -> thm
val unfold0: Proof.context -> thm list -> thm -> thm
val unfold0_goals: Proof.context -> thm list -> thm -> thm
val unfold0_tac: Proof.context -> thm list -> tactic
val unfold_abs_def: bool Config.T
val unfold_abs_def_raw: Config.raw
val unfold_goals: Proof.context -> thm list -> thm -> thm
val unfold_tac: Proof.context -> thm list -> tactic
end
Warning: Matches are not exhaustive.
fn (name, [th]) => (lhs, (name, ...))
At (line 114 of "Isar/local_defs.ML")
Warning: Pattern is not exhaustive.
val
([x'], ctxt') =
ctxt |> Variable.declare_term rhs |> Proof_Context.add_fixes [(...)]
At (line 123 of "Isar/local_defs.ML")
structure Local_Defs: LOCAL_DEFS
val it = (): unit
type local_theory
type generic_theory
structure Attrib:
sig
type binding = Binding.binding * Token.src list
type thms = (thm list * Token.src list) list
end
signature LOCAL_THEORY =
sig
val abbrev:
Syntax.mode ->
(binding * mixfix) * term ->
local_theory -> (term * term) * local_theory
val add_thms_dynamic:
binding * (Context.generic -> thm list) ->
local_theory -> local_theory
val assert: local_theory -> local_theory
val assert_bottom: local_theory -> local_theory
val assert_nonbrittle: local_theory -> local_theory
val background_naming_of: local_theory -> Name_Space.naming
val background_theory: (theory -> theory) -> local_theory -> local_theory
val background_theory_result:
(theory -> 'a * theory) -> local_theory -> 'a * local_theory
val close_target: local_theory -> local_theory
val const_alias: binding -> string -> local_theory -> local_theory
val declaration:
{pervasive: bool, syntax: bool} ->
declaration -> local_theory -> local_theory
val define:
(binding * mixfix) * (Attrib.binding * term) ->
local_theory -> (term * (string * thm)) * local_theory
val define_internal:
(binding * mixfix) * (Attrib.binding * term) ->
local_theory -> (term * (string * thm)) * local_theory
val exit: local_theory -> Proof.context
val exit_global: local_theory -> theory
val exit_result:
(morphism -> 'a -> 'b) -> 'a * local_theory -> 'b * Proof.context
val exit_result_global:
(morphism -> 'a -> 'b) -> 'a * local_theory -> 'b * theory
val full_name: local_theory -> binding -> string
val init:
{background_naming: Name_Space.naming,
exit: local_theory -> Proof.context} ->
operations -> Proof.context -> local_theory
val init_target:
{after_close: local_theory -> local_theory,
background_naming: Name_Space.naming} ->
operations -> local_theory -> Binding.scope * local_theory
val level: Proof.context -> int
val locale_dependency:
string * morphism ->
(morphism * bool) option -> morphism -> local_theory -> local_theory
val map_background_naming:
(Name_Space.naming -> Name_Space.naming) ->
local_theory -> local_theory
val map_contexts:
(int -> Proof.context -> Proof.context) ->
local_theory -> local_theory
val mark_brittle: local_theory -> local_theory
val new_group: local_theory -> local_theory
val notation:
bool ->
Syntax.mode -> (term * mixfix) list -> local_theory -> local_theory
val note:
Attrib.binding * thm list ->
local_theory -> (string * thm list) * local_theory
val notes:
(Attrib.binding * Attrib.thms) list ->
local_theory -> (string * thm list) list * local_theory
val notes_kind:
string ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> (string * thm list) list * local_theory
val open_target: local_theory -> Binding.scope * local_theory
type operations
val operations_of: local_theory -> operations
val pretty: local_theory -> Pretty.T list
val propagate_ml_env: generic_theory -> generic_theory
val raw_theory: (theory -> theory) -> local_theory -> local_theory
val raw_theory_result:
(theory -> 'a * theory) -> local_theory -> 'a * local_theory
val reset: local_theory -> local_theory
val reset_group: local_theory -> local_theory
val restore_background_naming:
local_theory -> local_theory -> local_theory
val set_defsort: sort -> local_theory -> local_theory
val standard_form:
local_theory -> Proof.context -> (morphism -> 'a) -> 'a
val standard_morphism: local_theory -> Proof.context -> morphism
val standard_morphism_theory: local_theory -> morphism
val target:
(Proof.context -> Proof.context) -> local_theory -> local_theory
val target_morphism: local_theory -> morphism
val target_of: local_theory -> Proof.context
val theory_registration:
string * morphism ->
(morphism * bool) option -> morphism -> local_theory -> local_theory
val type_alias: binding -> string -> local_theory -> local_theory
val type_notation:
bool ->
Syntax.mode -> (typ * mixfix) list -> local_theory -> local_theory
end
Warning: Matches are not exhaustive.
fn
{background_naming = background_naming, operations = ..., ...} :: parents
=> make_lthy (f (...)) :: parents
At (line 150 of "Isar/local_theory.ML")
Warning: Pattern is not exhaustive.
val ({after_close = after_close, ...} :: rest) = Data.get lthy
At (line 395 of "Isar/local_theory.ML")
structure Local_Theory: LOCAL_THEORY
val it = (): unit
signature ENTITY =
sig
type 'a data_ops =
{get_data: Context.generic -> 'a Name_Space.table,
put_data: 'a Name_Space.table -> Context.generic -> Context.generic}
val define:
'a data_ops -> binding -> 'a -> local_theory -> string * local_theory
val define_global:
'a data_ops -> binding -> 'a -> theory -> string * theory
end
structure Entity: ENTITY
val it = (): unit
signature COMMAND_SPAN =
sig
val content: span -> Token.T list
val kind: span -> kind
datatype kind =
Command_Span of string * Position.T
| Ignored_Span
| Malformed_Span
datatype span = Span of kind * Token.T list
end
structure Command_Span: COMMAND_SPAN
val it = (): unit
signature THY_SYNTAX =
sig
val atom: 'a -> 'a element
datatype 'a element = Element of 'a * ('a element list * 'a) option
val flat_element: 'a element -> 'a list
val last_element: 'a element -> 'a
val map_element: ('a -> 'b) -> 'a element -> 'b element
val parse_elements:
Keyword.keywords ->
Command_Span.span list -> Command_Span.span element list
end
structure Thy_Syntax: THY_SYNTAX
val it = (): unit
signature MARKDOWN =
sig
datatype block =
List of {body: block list, indent: int, kind: kind}
| Par of line list
val empty_line: line
val is_control: string -> bool
datatype kind = Description | Enumerate | Itemize
type line
val line_content: line -> Antiquote.text_antiquote list
val line_is_item: line -> bool
val line_source: line -> Antiquote.text_antiquote list
val make_line: Antiquote.text_antiquote list -> line
val print_kind: kind -> string
val read_antiquotes: Antiquote.text_antiquote list -> block list
val read_lines: line list -> block list
val read_source: Input.source -> block list
val reports: block list -> Position.report list
val text_reports: Antiquote.text_antiquote list -> Position.report list
end
structure Markdown: MARKDOWN
val it = (): unit
signature HTML =
sig
val begin_document: symbols -> string -> text
val begin_session_index:
symbols -> string -> Url.T -> (Url.T * string) list -> text
val end_document: text
val make_symbols: (string * int) list -> symbols
val no_symbols: symbols
val present_span:
symbols -> Keyword.keywords -> Command_Span.span -> string
type symbols
eqtype text
val theory:
symbols -> string -> (Url.T option * string) list -> text -> text
val theory_entry: symbols -> Url.T * string -> text
end
structure HTML: HTML
val it = (): unit
signature LATEX =
sig
val begin_delim: string -> string
val begin_tag: string -> string
val embed_raw: string -> string
val end_delim: string -> string
val end_tag: string -> string
val environment: string -> string -> string
val is_latex_control: string -> bool
val isabelle_theory: string -> string -> string
val latexN: string
val latex_control: string
val output_ascii: string -> string
val output_known_symbols:
(string -> bool) * (string -> bool) -> string list -> string
val output_symbols: string list -> string
val output_token: Token.T -> string
val symbol_source:
(string -> bool) * (string -> bool) -> string -> string list -> string
val tex_trailer: string
val theory_entry: string -> string
end
structure Latex: LATEX
val it = (): unit
Warning: Matches are not exhaustive.
fn Antiquote.Text tok => tok
At (line 120 of "ML/ml_context.ML")
signature ML_CONTEXT =
sig
val add_antiquotation:
binding ->
(Token.src -> Proof.context -> decl * Proof.context) ->
theory -> theory
val check_antiquotation: Proof.context -> xstring * Position.T -> string
type decl = Proof.context -> string * string
val eval:
ML_Compiler.flags ->
Position.T -> ML_Lex.token Antiquote.antiquote list -> unit
val eval_file: ML_Compiler.flags -> Path.T -> unit
val eval_in:
Proof.context option ->
ML_Compiler.flags ->
Position.T -> ML_Lex.token Antiquote.antiquote list -> unit
val eval_source: ML_Compiler.flags -> Input.source -> unit
val eval_source_in:
Proof.context option -> ML_Compiler.flags -> Input.source -> unit
val exec: (unit -> unit) -> Context.generic -> Context.generic
val expression:
Position.range ->
string ->
string ->
string ->
ML_Lex.token Antiquote.antiquote list ->
Context.generic -> Context.generic
val print_antiquotations: bool -> Proof.context -> unit
val struct_name: Proof.context -> string
val value_decl: string -> string -> Proof.context -> decl * Proof.context
val variant: string -> Proof.context -> string * Proof.context
end
structure ML_Context: ML_CONTEXT
val ML = fn: Input.source -> unit
val it = (): unit
signature ML_ANTIQUOTATION =
sig
val declaration:
binding ->
'a context_parser ->
(Token.src ->
'a -> Proof.context -> ML_Context.decl * Proof.context) ->
theory -> theory
val inline: binding -> string context_parser -> theory -> theory
val value: binding -> string context_parser -> theory -> theory
end
structure ML_Antiquotation: ML_ANTIQUOTATION
val it = (): unit
val ML_file = fn: string -> unit
val ML_file_debug = fn: string -> unit
val ML_file_no_debug = fn: string -> unit
val use = fn: string -> unit
val it = (): unit
val it = (): unit
signature BASIC_PAR_TACTICAL =
sig
val PARALLEL_ALLGOALS: (int -> tactic) -> tactic
val PARALLEL_CHOICE: tactic list -> tactic
val PARALLEL_GOALS: tactic -> tactic
end
signature PAR_TACTICAL =
sig
val PARALLEL_ALLGOALS: (int -> tactic) -> tactic
val PARALLEL_CHOICE: tactic list -> tactic
val PARALLEL_GOALS: tactic -> tactic
end
structure Par_Tactical: PAR_TACTICAL
structure Basic_Par_Tactical: BASIC_PAR_TACTICAL
val PARALLEL_ALLGOALS = fn: (int -> tactic) -> tactic
val PARALLEL_GOALS = fn: tactic -> tactic
val PARALLEL_CHOICE = fn: tactic list -> tactic
val it = (): unit
signature PROOF_DISPLAY =
sig
val method_error:
string ->
Position.T ->
{context: Proof.context, facts: thm list, goal: thm} ->
'a Seq.result
val pp_context: Proof.context -> Pretty.T
val pp_cterm: (unit -> theory) -> cterm -> Pretty.T
val pp_ctyp: (unit -> theory) -> ctyp -> Pretty.T
val pp_term: (unit -> theory) -> term -> Pretty.T
val pp_thm: (unit -> theory) -> thm -> Pretty.T
val pp_typ: (unit -> theory) -> typ -> Pretty.T
val pretty_definitions: bool -> Proof.context -> Pretty.T
val pretty_goal_facts: Proof.context -> string -> thm list -> Pretty.T
val pretty_goal_header: thm -> Pretty.T
val pretty_theorems: bool -> Proof.context -> Pretty.T list
val pretty_theorems_diff:
bool -> theory list -> Proof.context -> Pretty.T list
val pretty_theory: bool -> Proof.context -> Pretty.T
val print_consts:
bool ->
Position.T ->
Proof.context ->
(string * typ -> bool) -> (string * typ) list -> unit
val print_results:
bool ->
Position.T ->
Proof.context ->
(string * string) * (string * thm list) list -> unit
val string_of_goal: Proof.context -> thm -> string
val string_of_rule: Proof.context -> string -> thm -> string
end
structure Proof_Display: PROOF_DISPLAY
val it = (): unit
### ML warning (line 548 of "Isar/attrib.ML"):
### Pattern is not exhaustive.
signature ATTRIB =
sig
val add_del: attribute -> attribute -> attribute context_parser
val attribs: Token.src list context_parser
val attribute: Proof.context -> Token.src -> attribute
val attribute_cmd: Proof.context -> Token.src -> attribute
val attribute_cmd_global: theory -> Token.src -> attribute
val attribute_global: theory -> Token.src -> attribute
val attribute_setup:
bstring * Position.T ->
Input.source -> string -> local_theory -> local_theory
val attribute_syntax: attribute context_parser -> Token.src -> attribute
val case_conclusion: string * string list -> Token.src
val case_names: string list -> Token.src
val cases_open: Token.src
val check_name: Proof.context -> xstring * Position.T -> string
val check_name_generic:
Context.generic -> xstring * Position.T -> string
val check_src: Proof.context -> Token.src -> Token.src
val config_bool:
binding ->
(Context.generic -> bool) -> bool Config.T * (theory -> theory)
val config_int:
binding ->
(Context.generic -> int) -> int Config.T * (theory -> theory)
val config_real:
binding ->
(Context.generic -> real) -> real Config.T * (theory -> theory)
val config_string:
binding ->
(Context.generic -> string) -> string Config.T * (theory -> theory)
val constraints: int -> Token.src
val consumes: int -> Token.src
val define:
binding ->
(Token.src -> attribute) ->
string -> local_theory -> string * local_theory
val define_global:
binding ->
(Token.src -> attribute) -> string -> theory -> string * theory
val eval_thms:
Proof.context -> (Facts.ref * Token.src list) list -> thm list
val generic_notes:
string ->
(Attrib.binding * thms) list ->
Context.generic -> (string * thm list) list * Context.generic
val global_notes:
string ->
(Attrib.binding * thms) list ->
theory -> (string * thm list) list * theory
val internal: (morphism -> attribute) -> Token.src
val internal_declaration: declaration -> thms
val local_notes:
string ->
(Attrib.binding * thms) list ->
Proof.context -> (string * thm list) list * Proof.context
val local_setup:
binding ->
attribute context_parser -> string -> local_theory -> local_theory
val map_facts:
('a list -> 'b list) ->
(('c * 'a list) * ('d * 'a list) list) list ->
(('c * 'b list) * ('d * 'b list) list) list
val map_facts_refs:
('a list -> 'b list) ->
('c -> 'd) ->
(('e * 'a list) * ('c * 'a list) list) list ->
(('e * 'b list) * ('d * 'b list) list) list
val map_specs:
('a list -> 'b list) ->
(('c * 'a list) * 'd) list -> (('c * 'b list) * 'd) list
val multi_thm: thm list context_parser
val opt_attribs: Token.src list context_parser
val option_bool:
string * Position.T -> bool Config.T * (theory -> theory)
val option_int: string * Position.T -> int Config.T * (theory -> theory)
val option_real:
string * Position.T -> real Config.T * (theory -> theory)
val option_string:
string * Position.T -> string Config.T * (theory -> theory)
val partial_evaluation:
Proof.context ->
(Attrib.binding * thms) list -> (Attrib.binding * thms) list
val pretty_attribs: Proof.context -> Token.src list -> Pretty.T list
val pretty_binding:
Proof.context -> Attrib.binding -> string -> Pretty.T list
val print_attributes: bool -> Proof.context -> unit
val print_options: bool -> Proof.context -> unit
val setup:
binding -> attribute context_parser -> string -> theory -> theory
val setup_config_bool:
binding -> (Context.generic -> bool) -> bool Config.T
val setup_config_int:
binding -> (Context.generic -> int) -> int Config.T
val setup_config_real:
binding -> (Context.generic -> real) -> real Config.T
val setup_config_string:
binding -> (Context.generic -> string) -> string Config.T
val setup_option_bool: string * Position.T -> bool Config.T
val setup_option_int: string * Position.T -> int Config.T
val setup_option_real: string * Position.T -> real Config.T
val setup_option_string: string * Position.T -> string Config.T
val thm: thm context_parser
val thms: thm list context_parser
type thms = (thm list * Token.src list) list
val transform_facts:
morphism ->
(Attrib.binding * thms) list -> (Attrib.binding * thms) list
end
structure Attrib:
sig
val add_del: attribute -> attribute -> attribute context_parser
val attribs: Token.src list context_parser
val attribute: Proof.context -> Token.src -> attribute
val attribute_cmd: Proof.context -> Token.src -> attribute
val attribute_cmd_global: theory -> Token.src -> attribute
val attribute_global: theory -> Token.src -> attribute
val attribute_setup:
bstring * Position.T ->
Input.source -> string -> local_theory -> local_theory
val attribute_syntax: attribute context_parser -> Token.src -> attribute
type binding = ?.Attrib.binding
val case_conclusion: string * string list -> Token.src
val case_names: string list -> Token.src
val cases_open: Token.src
val check_name: Proof.context -> xstring * Position.T -> string
val check_name_generic:
Context.generic -> xstring * Position.T -> string
val check_src: Proof.context -> Token.src -> Token.src
val config_bool:
Binding.binding ->
(Context.generic -> bool) -> bool Config.T * (theory -> theory)
val config_int:
Binding.binding ->
(Context.generic -> int) -> int Config.T * (theory -> theory)
val config_real:
Binding.binding ->
(Context.generic -> real) -> real Config.T * (theory -> theory)
val config_string:
Binding.binding ->
(Context.generic -> string) -> string Config.T * (theory -> theory)
val constraints: int -> Token.src
val consumes: int -> Token.src
val define:
Binding.binding ->
(Token.src -> attribute) ->
string -> local_theory -> string * local_theory
val define_global:
Binding.binding ->
(Token.src -> attribute) -> string -> theory -> string * theory
val eval_thms:
Proof.context -> (Facts.ref * Token.src list) list -> thm list
val generic_notes:
string ->
(?.Attrib.binding * thms) list ->
Context.generic -> (string * thm list) list * Context.generic
val global_notes:
string ->
(?.Attrib.binding * thms) list ->
theory -> (string * thm list) list * theory
val internal: (morphism -> attribute) -> Token.src
val internal_declaration: declaration -> thms
val local_notes:
string ->
(?.Attrib.binding * thms) list ->
Proof.context -> (string * thm list) list * Proof.context
val local_setup:
Binding.binding ->
attribute context_parser -> string -> local_theory -> local_theory
val map_facts:
('a list -> 'b list) ->
(('c * 'a list) * ('d * 'a list) list) list ->
(('c * 'b list) * ('d * 'b list) list) list
val map_facts_refs:
('a list -> 'b list) ->
('c -> 'd) ->
(('e * 'a list) * ('c * 'a list) list) list ->
(('e * 'b list) * ('d * 'b list) list) list
val map_specs:
('a list -> 'b list) ->
(('c * 'a list) * 'd) list -> (('c * 'b list) * 'd) list
val multi_thm: thm list context_parser
val opt_attribs: Token.src list context_parser
val option_bool:
string * Position.T -> bool Config.T * (theory -> theory)
val option_int: string * Position.T -> int Config.T * (theory -> theory)
val option_real:
string * Position.T -> real Config.T * (theory -> theory)
val option_string:
string * Position.T -> string Config.T * (theory -> theory)
val partial_evaluation:
Proof.context ->
(?.Attrib.binding * thms) list -> (?.Attrib.binding * thms) list
val pretty_attribs: Proof.context -> Token.src list -> Pretty.T list
val pretty_binding:
Proof.context -> ?.Attrib.binding -> string -> Pretty.T list
val print_attributes: bool -> Proof.context -> unit
val print_options: bool -> Proof.context -> unit
val setup:
Binding.binding ->
attribute context_parser -> string -> theory -> theory
val setup_config_bool:
Binding.binding -> (Context.generic -> bool) -> bool Config.T
val setup_config_int:
Binding.binding -> (Context.generic -> int) -> int Config.T
val setup_config_real:
Binding.binding -> (Context.generic -> real) -> real Config.T
val setup_config_string:
Binding.binding -> (Context.generic -> string) -> string Config.T
val setup_option_bool: string * Position.T -> bool Config.T
val setup_option_int: string * Position.T -> int Config.T
val setup_option_real: string * Position.T -> real Config.T
val setup_option_string: string * Position.T -> string Config.T
val thm: thm context_parser
val thms: thm list context_parser
type thms = (thm list * Token.src list) list
val transform_facts:
morphism ->
(?.Attrib.binding * thms) list -> (?.Attrib.binding * thms) list
end
val it = (): unit
signature CONTEXT_RULES =
sig
val Swrap: Proof.context -> (int -> tactic) -> int -> tactic
val add:
(int option -> attribute) ->
(int option -> attribute) ->
(int option -> attribute) -> attribute context_parser
val addSWrapper:
(Proof.context -> (int -> tactic) -> int -> tactic) ->
theory -> theory
val addWrapper:
(Proof.context -> (int -> tactic) -> int -> tactic) ->
theory -> theory
val dest: int option -> attribute
val dest_bang: int option -> attribute
val dest_query: int option -> attribute
val elim: int option -> attribute
val elim_bang: int option -> attribute
val elim_query: int option -> attribute
val find_rules:
Proof.context -> bool -> thm list -> term -> thm list list
val find_rules_netpair:
Proof.context -> bool -> thm list -> term -> netpair -> thm list
val intro: int option -> attribute
val intro_bang: int option -> attribute
val intro_query: int option -> attribute
val netpair: Proof.context -> netpair
type netpair =
((int * int) * (bool * thm)) Net.net *
((int * int) * (bool * thm)) Net.net
val netpair_bang: Proof.context -> netpair
val orderlist: ((int * int) * 'a) list -> 'a list
val print_rules: Proof.context -> unit
val rule_del: attribute
val wrap: Proof.context -> (int -> tactic) -> int -> tactic
end
structure Context_Rules: CONTEXT_RULES
val it = (): unit
infix 1 CONTEXT_THEN_ALL_NEW
signature BASIC_METHOD =
sig
val CONTEXT_CASES: Rule_Cases.cases -> tactic -> context_tactic
val CONTEXT_SUBGOAL:
(term * int -> context_tactic) -> int -> context_tactic
val CONTEXT_THEN_ALL_NEW:
(int -> context_tactic) * (int -> tactic) -> int -> context_tactic
type context_state = Proof.context * thm
type context_tactic = context_state -> context_state Seq.result Seq.seq
end
signature METHOD =
sig
val CONTEXT:
Proof.context -> thm Seq.seq -> context_state Seq.result Seq.seq
val CONTEXT_CASES: Rule_Cases.cases -> tactic -> context_tactic
val CONTEXT_METHOD: (thm list -> context_tactic) -> method
val CONTEXT_SUBGOAL:
(term * int -> context_tactic) -> int -> context_tactic
val CONTEXT_TACTIC: tactic -> context_tactic
val CONTEXT_THEN_ALL_NEW:
(int -> context_tactic) * (int -> tactic) -> int -> context_tactic
val METHOD: (thm list -> tactic) -> method
val NO_CONTEXT_TACTIC: Proof.context -> context_tactic -> tactic
val RUNTIME: context_tactic -> context_tactic
val SIMPLE_METHOD: tactic -> method
val SIMPLE_METHOD': (int -> tactic) -> method
val SIMPLE_METHOD'':
((int -> tactic) -> tactic) -> (int -> tactic) -> method
val STATIC: (unit -> unit) -> context_tactic
val all_assm_tac: Proof.context -> tactic
val assm_tac: Proof.context -> int -> tactic
val assumption: Proof.context -> method
val atomize: bool -> Proof.context -> method
val cheating: bool -> method
val check_name: Proof.context -> xstring * Position.T -> string
val check_src: Proof.context -> Token.src -> Token.src
val check_text: Proof.context -> text -> text
val checked_text: text -> bool
val clean_facts: thm list -> thm list
val closure: bool Config.T
datatype combinator
= Orelse | Repeat1 | Select_Goals of int | Then | Then_All_New | Try
type combinator_info
type context_state = Proof.context * thm
type context_tactic = context_state -> context_state Seq.result Seq.seq
val detect_closure_state: thm -> bool
val done_text: text
val drule: Proof.context -> int -> thm list -> method
val elim: Proof.context -> thm list -> method
val erule: Proof.context -> int -> thm list -> method
val evaluate: text -> Proof.context -> method
val evaluate_runtime: text -> Proof.context -> method
val fact: thm list -> Proof.context -> method
val fail: method
val finish_text: text option * bool -> text
val fold: thm list -> Proof.context -> method
val frule: Proof.context -> int -> thm list -> method
val get_facts: Proof.context -> thm list
val goal_cases_tac: string list -> context_tactic
val insert: thm list -> method
val insert_tac: Proof.context -> thm list -> int -> tactic
val intro: Proof.context -> thm list -> method
val intros_tac: Proof.context -> thm list -> thm list -> tactic
val local_setup:
binding ->
(Proof.context -> method) context_parser ->
string -> local_theory -> local_theory
val map_source: (Token.src -> Token.src) -> text -> text
val method: Proof.context -> Token.src -> Proof.context -> method
type method = thm list -> context_tactic
val method_closure: Proof.context -> Token.src -> Token.src
val method_cmd: Proof.context -> Token.src -> Proof.context -> method
val method_setup:
bstring * Position.T ->
Input.source -> string -> local_theory -> local_theory
val method_syntax:
(Proof.context -> method) context_parser ->
Token.src -> Proof.context -> method
val modifier: attribute -> Position.T -> modifier
type modifier =
{attribute: attribute,
init: Proof.context -> Proof.context, pos: Position.T}
val no_combinator_info: combinator_info
val old_section_parser: bool Config.T
val parse: text_range parser
val parser: int -> text_range parser
val position: text_range option -> Position.T
val primitive_text: (Proof.context -> thm -> thm) -> text
val print_methods: bool -> Proof.context -> unit
val read: Proof.context -> Token.src -> text
val read_closure: Proof.context -> Token.src -> text * Token.src
val read_closure_input:
Proof.context -> Input.source -> text * Token.src
val report: text_range -> unit
val reports_of: text_range -> Position.report list
val rule: Proof.context -> thm list -> method
val rule_tac: Proof.context -> thm list -> thm list -> int -> tactic
val rule_trace: bool Config.T
val sections: modifier parser list -> unit context_parser
val set_facts: thm list -> Proof.context -> Proof.context
val set_tactic:
(morphism -> thm list -> tactic) ->
Context.generic -> Context.generic
val setup:
binding ->
(Proof.context -> method) context_parser ->
string -> theory -> theory
val sleep: Time.time -> context_tactic
val some_rule_tac:
Proof.context -> thm list -> thm list -> int -> tactic
val sorry_text: bool -> text
val standard_text: text
val succeed: method
val succeed_text: text
val text: text_range option -> text option
datatype text
=
Basic of Proof.context -> method
| Combinator of combinator_info * combinator * text list
| Source of Token.src
val text_closure: text context_parser
type text_range = text * Position.range
val this: Proof.context -> method
val this_text: text
val trace: Proof.context -> thm list -> unit
val try_intros_tac: Proof.context -> thm list -> thm list -> tactic
val unfold: thm list -> Proof.context -> method
end
structure Method: METHOD
structure Basic_Method: BASIC_METHOD
type context_tactic =
Basic_Method.context_state ->
Basic_Method.context_state Seq.result Seq.seq
type context_state = Proof.context * thm
val CONTEXT_THEN_ALL_NEW = fn:
(int -> context_tactic) * (int -> tactic) -> int -> context_tactic
val CONTEXT_SUBGOAL = fn:
(term * int -> context_tactic) -> int -> context_tactic
val CONTEXT_CASES = fn: Rule_Cases.cases -> tactic -> context_tactic
val CONTEXT_METHOD = fn: (thm list -> context_tactic) -> Method.method
val METHOD = fn: (thm list -> tactic) -> Method.method
val SIMPLE_METHOD = fn: tactic -> Method.method
val SIMPLE_METHOD' = fn: (int -> tactic) -> Method.method
val SIMPLE_METHOD'' = fn:
((int -> tactic) -> tactic) -> (int -> tactic) -> Method.method
val it = (): unit
### ML warning (line 1310 of "Isar/proof.ML"):
### Matches are not exhaustive.
### ML warning (line 1311 of "Isar/proof.ML"):
### Matches are not exhaustive.
signature PROOF =
sig
val apply: Method.text_range -> state -> state Seq.result Seq.seq
val apply_end: Method.text_range -> state -> state Seq.result Seq.seq
val assert_backward: state -> state
val assert_bottom: bool -> state -> state
val assert_chain: state -> state
val assert_forward: state -> state
val assert_forward_or_chain: state -> state
val assert_no_chain: state -> state
val assm:
Assumption.export ->
(binding * typ option * mixfix) list ->
(term * term list) list list ->
(Thm.binding * (term * term list) list) list -> state -> state
val assm_cmd:
Assumption.export ->
(binding * string option * mixfix) list ->
(string * string list) list list ->
(Attrib.binding * (string * string list) list) list ->
state -> state
val assume:
(binding * typ option * mixfix) list ->
(term * term list) list list ->
(Thm.binding * (term * term list) list) list -> state -> state
val assume_cmd:
(binding * string option * mixfix) list ->
(string * string list) list list ->
(Attrib.binding * (string * string list) list) list ->
state -> state
val begin_block: state -> state
val begin_notepad: context -> state
val case_:
Thm.binding * ((string * Position.T) * binding option list) ->
state -> state
val case_cmd:
Attrib.binding * ((string * Position.T) * binding option list) ->
state -> state
val chain: state -> state
val chain_facts: thm list -> state -> state
type context
val context_of: state -> context
val def:
(Thm.binding * ((binding * mixfix) * (term * term list))) list ->
state -> state
val def_cmd:
(Attrib.binding * ((binding * mixfix) * (string * string list))) list
-> state -> state
val defer: int -> state -> state
val define:
(binding * typ option * mixfix) list ->
(binding * typ option * mixfix) list ->
(Thm.binding * (term * term list) list) list -> state -> state
val define_cmd:
(binding * string option * mixfix) list ->
(binding * string option * mixfix) list ->
(Attrib.binding * (string * string list) list) list ->
state -> state
val end_block: state -> state
val end_notepad: state -> context
val enter_backward: state -> state
val enter_chain: state -> state
val enter_forward: state -> state
val fix: (binding * typ option * mixfix) list -> state -> state
val fix_cmd: (binding * string option * mixfix) list -> state -> state
val from_thmss: (thm list * attribute list) list list -> state -> state
val from_thmss_cmd:
(Facts.ref * Token.src list) list list -> state -> state
val future_proof:
(state -> ('a * context) future) -> state -> 'a future * state
val global_default_proof: state -> context
val global_done_proof: state -> context
val global_future_terminal_proof:
Method.text_range * Method.text_range option -> state -> context
val global_immediate_proof: state -> context
val global_qed: Method.text_range option * bool -> state -> context
val global_skip_proof: bool -> state -> context
val global_terminal_proof:
Method.text_range * Method.text_range option -> state -> context
val goal: state -> {context: context, facts: thm list, goal: thm}
val has_bottom_goal: state -> bool
val have:
bool ->
Method.text option ->
(context * thm list list -> state -> state) ->
(binding * typ option * mixfix) list ->
(Thm.binding * (term * term list) list) list ->
(Thm.binding * (term * term list) list) list ->
bool -> state -> thm list * state
val have_cmd:
bool ->
Method.text option ->
(context * thm list list -> state -> state) ->
(binding * string option * mixfix) list ->
(Attrib.binding * (string * string list) list) list ->
(Attrib.binding * (string * string list) list) list ->
bool -> state -> thm list * state
val improper_reset_facts: state -> state
val init: context -> state
val internal_goal:
(context -> (string * string) * (string * thm list) list -> unit) ->
Proof_Context.mode ->
bool ->
string ->
Method.text option ->
(context * thm list list -> state -> state) ->
(binding * typ option * mixfix) list ->
(Thm.binding * (term * term list) list) list ->
(Thm.binding * (term * term list) list) list ->
state -> thm list * state
val is_relevant: state -> bool
val let_bind: (term list * term) list -> state -> state
val let_bind_cmd: (string list * string) list -> state -> state
val level: state -> int
val local_default_proof: state -> state
val local_done_proof: state -> state
val local_future_terminal_proof:
Method.text_range * Method.text_range option -> state -> state
val local_immediate_proof: state -> state
val local_qed: Method.text_range option * bool -> state -> state
val local_skip_proof: bool -> state -> state
val local_terminal_proof:
Method.text_range * Method.text_range option -> state -> state
val map_context: (context -> context) -> state -> state
val map_context_result: (context -> 'a * context) -> state -> 'a * state
val map_contexts: (context -> context) -> state -> state
type method = Method.method
val next_block: state -> state
val note_thmss:
(Thm.binding * (thm list * attribute list) list) list ->
state -> state
val note_thmss_cmd:
(Attrib.binding * (Facts.ref * Token.src list) list) list ->
state -> state
val prefer: int -> state -> state
val presume:
(binding * typ option * mixfix) list ->
(term * term list) list list ->
(Thm.binding * (term * term list) list) list -> state -> state
val presume_cmd:
(binding * string option * mixfix) list ->
(string * string list) list list ->
(Attrib.binding * (string * string list) list) list ->
state -> state
val pretty_state: state -> Pretty.T list
val proof: Method.text_range option -> state -> state Seq.result Seq.seq
val propagate_ml_env: state -> state
val raw_goal: state -> {context: context, facts: thm list, goal: thm}
val refine: Method.text -> state -> state Seq.result Seq.seq
val refine_end: Method.text -> state -> state Seq.result Seq.seq
val refine_insert: thm list -> state -> state
val refine_primitive: (context -> thm -> thm) -> state -> state
val refine_singleton: Method.text -> state -> state
val report_improper: state -> unit
val reset_facts: state -> state
val schematic_goal: state -> bool
val set_facts: thm list -> state -> state
val show:
bool ->
Method.text option ->
(context * thm list list -> state -> state) ->
(binding * typ option * mixfix) list ->
(Thm.binding * (term * term list) list) list ->
(Thm.binding * (term * term list) list) list ->
bool -> state -> thm list * state
val show_cmd:
bool ->
Method.text option ->
(context * thm list list -> state -> state) ->
(binding * string option * mixfix) list ->
(Attrib.binding * (string * string list) list) list ->
(Attrib.binding * (string * string list) list) list ->
bool -> state -> thm list * state
val simple_goal: state -> {context: context, goal: thm}
type state
val supply:
(Thm.binding * (thm list * attribute list) list) list ->
state -> state
val supply_cmd:
(Attrib.binding * (Facts.ref * Token.src list) list) list ->
state -> state
val the_fact: state -> thm
val the_facts: state -> thm list
val theorem:
Method.text option ->
(thm list list -> context -> context) ->
(term * term list) list list -> context -> state
val theorem_cmd:
Method.text option ->
(thm list list -> context -> context) ->
(string * string list) list list -> context -> state
val theory_of: state -> theory
val unfolding: (thm list * attribute list) list list -> state -> state
val unfolding_cmd:
(Facts.ref * Token.src list) list list -> state -> state
val using: (thm list * attribute list) list list -> state -> state
val using_cmd: (Facts.ref * Token.src list) list list -> state -> state
val using_facts: thm list -> state -> state
val with_thmss: (thm list * attribute list) list list -> state -> state
val with_thmss_cmd:
(Facts.ref * Token.src list) list list -> state -> state
val write: Syntax.mode -> (term * mixfix) list -> state -> state
val write_cmd: Syntax.mode -> (string * mixfix) list -> state -> state
end
structure Proof: PROOF
val it = (): unit
### ML warning (line 230 of "Isar/element.ML"):
### Pattern is not exhaustive.
signature ELEMENT =
sig
val activate:
(typ, term, Facts.ref) ctxt ->
Proof.context -> context_i * Proof.context
val activate_i: context_i -> Proof.context -> context_i * Proof.context
val conclude_witness: Proof.context -> witness -> thm
type context = (string, string, Facts.ref) ctxt
type context_i = (typ, term, thm list) ctxt
datatype ('a, 'b, 'c) ctxt
=
Assumes of (Attrib.binding * ('b * 'b list) list) list
| Constrains of (string * 'a) list
| Defines of (Attrib.binding * ('b * 'b list)) list
| Fixes of (binding * 'a option * mixfix) list
| Notes of
string * (Attrib.binding * ('c * Token.src list) list) list
val eq_morphism: theory -> thm list -> morphism option
val init: context_i -> Context.generic -> Context.generic
val init': context_i -> Context.generic -> Context.generic
val instT_morphism: theory -> typ Symtab.table -> morphism
val inst_morphism:
theory -> typ Symtab.table * term Symtab.table -> morphism
val map_ctxt:
{attrib: Token.src -> Token.src,
binding: binding -> binding,
fact: 'a -> 'b, pattern: 'c -> 'd, term: 'c -> 'd, typ: 'e -> 'f}
-> ('e, 'c, 'a) ctxt -> ('f, 'd, 'b) ctxt
val map_ctxt_attrib:
(Token.src -> Token.src) -> ('a, 'b, 'c) ctxt -> ('a, 'b, 'c) ctxt
type ('a, 'b) obtain =
binding * ((binding * 'a option * mixfix) list * 'b list)
type obtains = (string, string) obtain list
type obtains_i = (typ, term) obtain list
val pretty_ctxt: Proof.context -> context_i -> Pretty.T list
val pretty_ctxt_no_attribs: Proof.context -> context_i -> Pretty.T list
val pretty_statement: Proof.context -> string -> thm -> Pretty.T
val pretty_stmt: Proof.context -> statement_i -> Pretty.T list
val pretty_witness: Proof.context -> witness -> Pretty.T
val prove_witness: Proof.context -> term -> tactic -> witness
val satisfy_morphism: witness list -> morphism
type statement = (string, string) stmt
type statement_i = (typ, term) stmt
datatype ('a, 'b) stmt
=
Obtains of ('a, 'b) obtain list
| Shows of (Attrib.binding * ('b * 'b list) list) list
val transform_ctxt: morphism -> context_i -> context_i
val transform_witness: morphism -> witness -> witness
type witness
val witness_local_proof:
(witness list list -> Proof.state -> Proof.state) ->
string ->
term list list -> Proof.context -> Proof.state -> Proof.state
val witness_local_proof_eqs:
(witness list list -> thm list -> Proof.state -> Proof.state) ->
string ->
term list list ->
term list -> Proof.context -> Proof.state -> Proof.state
val witness_proof:
(witness list list -> Proof.context -> Proof.context) ->
term list list -> Proof.context -> Proof.state
val witness_proof_eqs:
(witness list list -> thm list -> Proof.context -> Proof.context) ->
term list list -> term list -> Proof.context -> Proof.state
end
structure Element: ELEMENT
val it = (): unit
### ML warning (line 59 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
### ML warning (line 91 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
### ML warning (line 220 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
### ML warning (line 267 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
### ML warning (line 334 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
### ML warning (line 385 of "Isar/obtain.ML"):
### Matches are not exhaustive.
### ML warning (line 392 of "Isar/obtain.ML"):
### Pattern is not exhaustive.
signature OBTAIN =
sig
val cert_obtains:
Proof.context -> term -> Element.obtains_i -> (binding * term) list
val consider: Element.obtains_i -> bool -> Proof.state -> Proof.state
val consider_cmd: Element.obtains -> bool -> Proof.state -> Proof.state
val guess:
(binding * typ option * mixfix) list ->
bool -> Proof.state -> Proof.state
val guess_cmd:
(binding * string option * mixfix) list ->
bool -> Proof.state -> Proof.state
val obtain:
binding ->
(binding * typ option * mixfix) list ->
(binding * typ option * mixfix) list ->
(term * term list) list list ->
(Thm.binding * (term * term list) list) list ->
bool -> Proof.state -> Proof.state
val obtain_cmd:
binding ->
(binding * string option * mixfix) list ->
(binding * string option * mixfix) list ->
(string * string list) list list ->
(Attrib.binding * (string * string list) list) list ->
bool -> Proof.state -> Proof.state
val obtain_thesis:
Proof.context -> ((string * typ) * term) * Proof.context
val obtains_attribs: ('a, 'b) Element.obtain list -> Token.src list
val obtains_attributes: ('a, 'b) Element.obtain list -> attribute list
val parse_obtains:
Proof.context -> term -> Element.obtains -> (binding * term) list
val read_obtains:
Proof.context -> term -> Element.obtains -> (binding * term) list
val result:
(Proof.context -> tactic) ->
thm list ->
Proof.context ->
((string * cterm) list * thm list) * Proof.context
end
structure Obtain: OBTAIN
val it = (): unit
### ML warning (line 49 of "Isar/subgoal.ML"):
### Pattern is not exhaustive.
### ML warning (line 84 of "Isar/subgoal.ML"):
### Pattern is not exhaustive.
### ML warning (line 216 of "Isar/subgoal.ML"):
### Matches are not exhaustive.
signature SUBGOAL =
sig
val FOCUS: (focus -> tactic) -> Proof.context -> int -> tactic
val FOCUS_PARAMS: (focus -> tactic) -> Proof.context -> int -> tactic
val FOCUS_PARAMS_FIXED:
(focus -> tactic) -> Proof.context -> int -> tactic
val FOCUS_PREMS: (focus -> tactic) -> Proof.context -> int -> tactic
val SUBPROOF: (focus -> tactic) -> Proof.context -> int -> tactic
val focus:
Proof.context -> int -> binding list option -> thm -> focus * thm
type focus =
{asms: cterm list,
concl: cterm,
context: Proof.context,
params: (string * cterm) list,
prems: thm list,
schematics:
((indexname * sort) * ctyp) list * ((indexname * typ) * cterm) list}
val focus_params:
Proof.context -> int -> binding list option -> thm -> focus * thm
val focus_params_fixed:
Proof.context -> int -> binding list option -> thm -> focus * thm
val focus_prems:
Proof.context -> int -> binding list option -> thm -> focus * thm
val retrofit:
Proof.context ->
Proof.context ->
(string * cterm) list ->
cterm list -> int -> thm -> thm -> thm Seq.seq
val subgoal:
Attrib.binding ->
Attrib.binding option ->
bool * (string option * Position.T) list ->
Proof.state -> focus * Proof.state
val subgoal_cmd:
Attrib.binding ->
Attrib.binding option ->
bool * (string option * Position.T) list ->
Proof.state -> focus * Proof.state
end
structure Subgoal: SUBGOAL
val SUBPROOF = fn:
(Subgoal.focus -> tactic) -> Proof.context -> int -> tactic
val it = (): unit
signature CALCULATION =
sig
val also:
thm list option ->
bool -> Proof.state -> Proof.state Seq.result Seq.seq
val also_cmd:
(Facts.ref * Token.src list) list option ->
bool -> Proof.state -> Proof.state Seq.result Seq.seq
val check: Proof.state -> thm list option
val finally:
thm list option ->
bool -> Proof.state -> Proof.state Seq.result Seq.seq
val finally_cmd:
(Facts.ref * Token.src list) list option ->
bool -> Proof.state -> Proof.state Seq.result Seq.seq
val moreover: bool -> Proof.state -> Proof.state
val print_rules: Proof.context -> unit
val sym_add: attribute
val sym_del: attribute
val symmetric: attribute
val trans_add: attribute
val trans_del: attribute
val ultimately: bool -> Proof.state -> Proof.state
end
structure Calculation: CALCULATION
val it = (): unit
### ML warning (line 234 of "Isar/locale.ML"):
### Value identifier (identity_on) has not been referenced.
signature LOCALE =
sig
val activate_declarations:
string * morphism -> Proof.context -> Proof.context
val activate_facts:
morphism option ->
string * morphism -> Context.generic -> Context.generic
val activate_fragment:
string * morphism ->
(morphism * bool) option ->
morphism -> local_theory -> local_theory
val activate_fragment_nonbrittle:
string * morphism ->
(morphism * bool) option ->
morphism -> local_theory -> local_theory
val add_declaration:
string -> bool -> declaration -> Proof.context -> Proof.context
val add_dependency:
string ->
string * morphism ->
(morphism * bool) option -> morphism -> theory -> theory
val add_registration:
string * morphism ->
(morphism * bool) option ->
morphism -> Context.generic -> Context.generic
val add_thmss:
string ->
string ->
(Attrib.binding * Attrib.thms) list ->
Proof.context -> Proof.context
val all_registrations_of: Context.generic -> (string * morphism) list
val amend_registration:
string * morphism ->
morphism * bool -> morphism -> Context.generic -> Context.generic
val axioms_of: theory -> string -> thm list
val check: theory -> xstring * Position.T -> string
val defined: theory -> string -> bool
val extern: theory -> string -> xstring
val get_intros: Proof.context -> thm list
val get_unfolds: Proof.context -> thm list
val get_witnesses: Proof.context -> thm list
val hyp_spec_of: theory -> string -> Element.context_i list
val init: string -> theory -> Proof.context
val instance_of: theory -> string -> morphism -> term list
val intern: theory -> xstring -> string
val intro_add: attribute
val intro_locales_tac: bool -> Proof.context -> thm list -> tactic
val intros_of: theory -> string -> thm option * thm option
val markup_name: Proof.context -> string -> string
val params_of: theory -> string -> ((string * typ) * mixfix) list
val pretty_locale: theory -> bool -> string -> Pretty.T list
val pretty_locale_deps:
theory -> {body: Pretty.T, name: string, parents: string list} list
val pretty_name: Proof.context -> string -> Pretty.T
val print_dependencies:
Proof.context -> bool -> morphism -> (string * morphism) list -> unit
val print_locale: theory -> bool -> xstring * Position.T -> unit
val print_locales: bool -> theory -> unit
val print_registrations: Proof.context -> xstring * Position.T -> unit
val register_locale:
binding ->
(string * sort) list * ((string * typ) * mixfix) list ->
term option * term list ->
thm option * thm option ->
thm list ->
Element.context_i list ->
declaration list ->
(string * (Attrib.binding * Attrib.thms) list) list ->
(string * morphism) list -> theory -> theory
val registrations_of:
Context.generic -> string -> (string * morphism) list
val specification_of: theory -> string -> term option * term list
val unfold_add: attribute
val witness_add: attribute
end
structure Locale: LOCALE
val it = (): unit
### ML warning (line 160 of "Isar/generic_target.ML"):
### Matches are not exhaustive.
### ML warning (line 249 of "Isar/generic_target.ML"):
### Pattern is not exhaustive.
### ML warning (line 258 of "Isar/generic_target.ML"):
### Pattern is not exhaustive.
### ML warning (line 279 of "Isar/generic_target.ML"):
### Pattern is not exhaustive.
signature GENERIC_TARGET =
sig
val abbrev:
(Syntax.mode ->
binding * mixfix ->
term -> term list * term list -> local_theory -> local_theory)
->
Syntax.mode ->
(binding * mixfix) * term ->
local_theory -> (term * term) * local_theory
val background_abbrev:
binding * term ->
term list -> local_theory -> (term * term) * local_theory
val background_declaration: declaration -> local_theory -> local_theory
val background_foundation:
((binding * typ) * mixfix) * (binding * term) ->
term list * term list ->
local_theory -> (term * thm) * local_theory
val check_mixfix:
Proof.context -> binding * (string * sort) list -> mixfix -> mixfix
val check_mixfix_global: binding * bool -> mixfix -> mixfix
val define:
(((binding * typ) * mixfix) * (binding * term) ->
term list * term list ->
local_theory -> (term * thm) * local_theory)
->
bool ->
(binding * mixfix) * (Attrib.binding * term) ->
local_theory -> (term * (string * thm)) * local_theory
val export_abbrev:
Proof.context ->
(term -> term) ->
term -> term * ((string * sort) list * (term list * term list))
val init:
{background_naming: Name_Space.naming,
conclude: local_theory -> local_theory,
setup: theory -> Proof.context}
-> Local_Theory.operations -> theory -> local_theory
val locale_abbrev:
string ->
Syntax.mode ->
(binding * mixfix) * term ->
local_theory -> (term * term) * local_theory
val locale_const:
string ->
Syntax.mode ->
(binding * mixfix) * term -> local_theory -> local_theory
val locale_declaration:
string ->
{pervasive: bool, syntax: bool} ->
declaration -> local_theory -> local_theory
val locale_dependency:
string ->
string * morphism ->
(morphism * bool) option ->
morphism -> local_theory -> local_theory
val locale_target_abbrev:
string ->
Syntax.mode ->
binding * mixfix ->
term -> term list * term list -> local_theory -> local_theory
val locale_target_const:
string ->
(morphism -> bool) ->
Syntax.mode ->
(binding * mixfix) * term -> local_theory -> local_theory
val locale_target_declaration:
string -> bool -> declaration -> local_theory -> local_theory
val locale_target_notes:
string ->
string ->
(Attrib.binding * Attrib.thms) list ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> local_theory
val notes:
(string ->
(Attrib.binding * Attrib.thms) list ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> local_theory)
->
string ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> (string * thm list) list * local_theory
val standard_const:
(int * int -> bool) ->
Syntax.mode ->
(binding * mixfix) * term -> local_theory -> local_theory
val standard_declaration:
(int * int -> bool) ->
(morphism -> Context.generic -> Context.generic) ->
local_theory -> local_theory
val standard_facts:
local_theory ->
Proof.context ->
(Attrib.binding * Attrib.thms) list ->
(Attrib.binding * Attrib.thms) list
val standard_notes:
(int * int -> bool) ->
string ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> local_theory
val theory_abbrev:
Syntax.mode ->
(binding * mixfix) * term ->
local_theory -> (term * term) * local_theory
val theory_declaration: declaration -> local_theory -> local_theory
val theory_registration:
string * morphism ->
(morphism * bool) option ->
morphism -> local_theory -> local_theory
val theory_target_abbrev:
Syntax.mode ->
binding * mixfix ->
term -> term list * term list -> local_theory -> local_theory
val theory_target_foundation:
((binding * typ) * mixfix) * (binding * term) ->
term list * term list ->
local_theory -> (term * thm) * local_theory
val theory_target_notes:
string ->
(Attrib.binding * Attrib.thms) list ->
(Attrib.binding * Attrib.thms) list ->
local_theory -> local_theory
end
structure Generic_Target: GENERIC_TARGET
val it = (): unit
### ML warning (line 51 of "Isar/overloading.ML"):
### Value identifier (secondary_pass) has not been referenced.
signature OVERLOADING =
sig
val activate_improvable_syntax: Proof.context -> Proof.context
type improvable_syntax
val map_improvable_syntax:
(improvable_syntax -> improvable_syntax) ->
Proof.context -> Proof.context
val overloading:
(string * (string * typ) * bool) list -> theory -> local_theory
val overloading_cmd:
(string * string * bool) list -> theory -> local_theory
val set_primary_constraints: Proof.context -> Proof.context
val show_reverted_improvements: bool Config.T
end
structure Overloading: OVERLOADING
val it = (): unit
### ML warning (line 356 of "axclass.ML"):
### Matches are not exhaustive.
### ML warning (line 417 of "axclass.ML"):
### Value identifier (S) has not been referenced.
### ML warning (line 453 of "axclass.ML"):
### Value identifier (names) has not been referenced.
### ML warning (line 535 of "axclass.ML"):
### Pattern is not exhaustive.
### ML warning (line 546 of "axclass.ML"):
### Pattern is not exhaustive.
### ML warning (line 592 of "axclass.ML"):
### Value identifier (class_const) has not been referenced.
signature AXCLASS =
sig
val add_arity: thm -> theory -> theory
val add_classrel: thm -> theory -> theory
val arity_axiomatization: arity -> theory -> theory
val cert_classrel: theory -> class * class -> class * class
val class_axiomatization: binding * class list -> theory -> theory
val class_of_param: theory -> string -> class option
val classrel_axiomatization: (class * class) list -> theory -> theory
val declare_overloaded: string * typ -> theory -> term * theory
val define_class:
binding * class list ->
string list ->
(Thm.binding * term list) list -> theory -> class * theory
val define_overloaded:
binding -> string * term -> theory -> thm * theory
val get_info: theory -> class -> info
type info =
{axioms: thm list, def: thm, intro: thm, params: (string * typ) list}
val inst_of_param: theory -> string -> (string * string) option
val instance_name: string * class -> string
val lookup_inst_param:
Consts.T ->
((string * string) * 'a) list -> string * typ -> 'a option
val overload: Proof.context -> thm -> thm
val overload_conv: Proof.context -> conv
val param_of_inst: theory -> string * string -> string
val prove_arity:
string * sort list * sort ->
(Proof.context -> tactic) -> theory -> theory
val prove_classrel:
class * class -> (Proof.context -> tactic) -> theory -> theory
val read_classrel: theory -> xstring * xstring -> class * class
val thynames_of_arity: theory -> string * class -> string list
val unoverload: Proof.context -> thm -> thm
val unoverload_const: theory -> string * typ -> string
val unoverload_conv: Proof.context -> conv
end
structure Axclass: AXCLASS
val it = (): unit
### ML warning (line 266 of "Isar/class.ML"):
### Value identifier (t') has not been referenced.
### ML warning (line 383 of "Isar/class.ML"):
### Value identifier (phi) has not been referenced.
### ML warning (line 420 of "Isar/class.ML"):
### Value identifier (phi) has not been referenced.
### ML warning (line 440 of "Isar/class.ML"):
### Value identifier (type_params) has not been referenced.
### ML warning (line 440 of "Isar/class.ML"):
### Value identifier (extra_tfrees) has not been referenced.
### ML warning (line 486 of "Isar/class.ML"):
### Value identifier (some_wit) has not been referenced.
signature CLASS =
sig
val abbrev:
class ->
Syntax.mode ->
(binding * mixfix) * term ->
local_theory -> (term * term) * local_theory
val base_sort: theory -> class -> sort
val begin: class list -> sort -> Proof.context -> Proof.context
val class_prefix: string -> string
val classrel: class * class -> theory -> Proof.state
val classrel_cmd: xstring * xstring -> theory -> Proof.state
val const:
class ->
(binding * mixfix) * term ->
term list * term list -> local_theory -> local_theory
val init: class -> theory -> Proof.context
val instance_arity_cmd:
xstring list * xstring list * xstring -> theory -> Proof.state
val instantiation:
string list * (string * sort) list * sort -> theory -> local_theory
val instantiation_cmd:
xstring list * xstring list * xstring -> theory -> local_theory
val instantiation_instance:
(local_theory -> local_theory) -> local_theory -> Proof.state
val intro_classes_tac: Proof.context -> thm list -> tactic
val is_class: theory -> class -> bool
val pretty_specification: theory -> class -> Pretty.T list
val print_classes: Proof.context -> unit
val prove_instantiation_exit:
(Proof.context -> tactic) -> local_theory -> theory
val prove_instantiation_exit_result:
(morphism -> 'a -> 'b) ->
(Proof.context -> 'b -> tactic) ->
'a -> local_theory -> 'b * theory
val prove_instantiation_instance:
(Proof.context -> tactic) -> local_theory -> local_theory
val read_multi_arity:
theory ->
xstring list * xstring list * xstring ->
string list * (string * sort) list * sort
val redeclare_operations:
theory -> sort -> Proof.context -> Proof.context
val register:
class ->
class list ->
((string * typ) * (string * typ)) list ->
sort ->
morphism ->
morphism ->
thm option -> thm option -> thm -> theory -> theory
val register_subclass:
class * class ->
morphism option ->
Element.witness option ->
morphism -> local_theory -> local_theory
val rules: theory -> class -> thm option * thm
val standard_intro_classes_tac: Proof.context -> thm list -> tactic
val these_defs: theory -> sort -> thm list
val these_operations:
theory -> sort -> (string * (class * ((typ * term) * bool))) list
val these_params:
theory -> sort -> (string * (class * (string * typ))) list
end
structure Class: CLASS
val it = (): unit
signature NAMED_TARGET =
sig
val begin: xstring * Position.T -> theory -> local_theory
val bottom_locale_of: local_theory -> string option
val class_of: local_theory -> string option
val exit: local_theory -> theory
val init: string -> theory -> local_theory
val init':
{conclude: local_theory -> local_theory,
setup: local_theory -> local_theory}
-> string -> theory -> local_theory
val is_theory: local_theory -> bool
val locale_of: local_theory -> string option
val switch:
(xstring * Position.T) option ->
Context.generic -> (local_theory -> Context.generic) * local_theory
val theory_init: theory -> local_theory
val theory_map: (local_theory -> local_theory) -> theory -> theory
end
structure Named_Target: NAMED_TARGET
val it = (): unit
### ML warning (line 228 of "Isar/expression.ML"):
### Matches are not exhaustive.
### ML warning (line 229 of "Isar/expression.ML"):
### Matches are not exhaustive.
### ML warning (line 250 of "Isar/expression.ML"):
### Matches are not exhaustive.
### ML warning (line 253 of "Isar/expression.ML"):
### Matches are not exhaustive.
### ML warning (line 275 of "Isar/expression.ML"):
### Pattern is not exhaustive.
### ML warning (line 277 of "Isar/expression.ML"):
### Pattern is not exhaustive.
### ML warning (line 415 of "Isar/expression.ML"):
### Matches are not exhaustive.
### ML warning (line 673 of "Isar/expression.ML"):
### Pattern is not exhaustive.
### ML warning (line 764 of "Isar/expression.ML"):
### Value identifier (defs) has not been referenced.
### ML warning (line 764 of "Isar/expression.ML"):
### Value identifier (elem) has not been referenced.
### ML warning (line 763 of "Isar/expression.ML"):
### Value identifier (asms) has not been referenced.
### ML warning (line 763 of "Isar/expression.ML"):
### Value identifier (elem) has not been referenced.
### ML warning (line 800 of "Isar/expression.ML"):
### Matches are not exhaustive.
signature EXPRESSION =
sig
val add_locale:
binding ->
binding ->
expression_i ->
Element.context_i list -> theory -> string * local_theory
val add_locale_cmd:
binding ->
binding ->
expression ->
Element.context list -> theory -> string * local_theory
val cert_declaration:
expression_i ->
(Proof.context -> Proof.context) ->
Element.context_i list ->
Proof.context ->
(((string * typ) * mixfix) list * (string * morphism) list *
Element.context_i list * Proof.context)
*
((string * typ) list * Proof.context)
val cert_goal_expression:
expression_i ->
Proof.context ->
(term list list * (string * morphism) list * morphism) *
Proof.context
val cert_read_declaration:
expression_i ->
(Proof.context -> Proof.context) ->
Element.context list ->
Proof.context ->
(((string * typ) * mixfix) list * (string * morphism) list *
Element.context_i list * Proof.context)
*
((string * typ) list * Proof.context)
val cert_statement:
Element.context_i list ->
Element.statement_i ->
Proof.context ->
(Attrib.binding * (term * term list) list) list * Proof.context
type ('a, 'b) expr = ('a * ((string * bool) * 'b map)) list
type expression =
(xstring * Position.T, string) expr *
(binding * string option * mixfix) list
type expression_i =
(string, term) expr * (binding * typ option * mixfix) list
datatype 'a map
= Named of (string * 'a) list | Positional of 'a option list
val print_dependencies: Proof.context -> bool -> expression -> unit
val read_declaration:
expression ->
(Proof.context -> Proof.context) ->
Element.context list ->
Proof.context ->
(((string * typ) * mixfix) list * (string * morphism) list *
Element.context_i list * Proof.context)
*
((string * typ) list * Proof.context)
val read_goal_expression:
expression ->
Proof.context ->
(term list list * (string * morphism) list * morphism) *
Proof.context
val read_statement:
Element.context list ->
Element.statement ->
Proof.context ->
(Attrib.binding * (term * term list) list) list * Proof.context
end
structure Expression: EXPRESSION
val it = (): unit
### ML warning (line 58 of "Isar/interpretation.ML"):
### Value identifier (deps) has not been referenced.
### ML warning (line 66 of "Isar/interpretation.ML"):
### Value identifier (deps) has not been referenced.
### ML warning (line 66 of "Isar/interpretation.ML"):
### Value identifier (prep_term) has not been referenced.
### ML warning (line 82 of "Isar/interpretation.ML"):
### Value identifier (ctxt) has not been referenced.
### ML warning (line 82 of "Isar/interpretation.ML"):
### Value identifier (deps) has not been referenced.
### ML warning (line 82 of "Isar/interpretation.ML"):
### Value identifier (prep_attr) has not been referenced.
### ML warning (line 82 of "Isar/interpretation.ML"):
### Value identifier (prep_props) has not been referenced.
signature INTERPRETATION =
sig
type 'a defines = (Attrib.binding * ((binding * mixfix) * 'a)) list
val global_interpretation:
Expression.expression_i ->
term defines -> term rewrites -> local_theory -> Proof.state
val global_interpretation_cmd:
Expression.expression ->
string defines -> string rewrites -> local_theory -> Proof.state
val global_sublocale:
string ->
Expression.expression_i ->
term defines -> term rewrites -> theory -> Proof.state
val global_sublocale_cmd:
xstring * Position.T ->
Expression.expression ->
string defines -> string rewrites -> theory -> Proof.state
val interpret:
Expression.expression_i ->
term rewrites -> Proof.state -> Proof.state
val interpret_cmd:
Expression.expression ->
string rewrites -> Proof.state -> Proof.state
val interpretation:
Expression.expression_i ->
term rewrites -> local_theory -> Proof.state
val interpretation_cmd:
Expression.expression ->
string rewrites -> local_theory -> Proof.state
val isar_interpretation:
Expression.expression_i ->
term rewrites -> local_theory -> Proof.state
val isar_interpretation_cmd:
Expression.expression ->
string rewrites -> local_theory -> Proof.state
type 'a rewrites = (Attrib.binding * 'a) list
val sublocale:
Expression.expression_i ->
term defines -> term rewrites -> local_theory -> Proof.state
val sublocale_cmd:
Expression.expression ->
string defines -> string rewrites -> local_theory -> Proof.state
end
structure Interpretation: INTERPRETATION
val it = (): unit
### ML warning (line 41 of "Isar/class_declaration.ML"):
### Pattern is not exhaustive.
### ML warning (line 74 of "Isar/class_declaration.ML"):
### Pattern is not exhaustive.
### ML warning (line 179 of "Isar/class_declaration.ML"):
### Matches are not exhaustive.
### ML warning (line 179 of "Isar/class_declaration.ML"):
### Matches are not exhaustive.
### ML warning (line 236 of "Isar/class_declaration.ML"):
### Matches are not exhaustive.
### ML warning (line 297 of "Isar/class_declaration.ML"):
### Matches are not exhaustive.
### ML warning (line 358 of "Isar/class_declaration.ML"):
### Pattern is not exhaustive.
signature CLASS_DECLARATION =
sig
val class:
binding ->
class list ->
Element.context_i list -> theory -> string * local_theory
val class_cmd:
binding ->
xstring list ->
Element.context list -> theory -> string * local_theory
val prove_subclass: tactic -> class -> local_theory -> local_theory
val subclass: class -> local_theory -> Proof.state
val subclass_cmd: xstring -> local_theory -> Proof.state
end
structure Class_Declaration: CLASS_DECLARATION
val it = (): unit
signature BUNDLE =
sig
val bundle:
binding * Attrib.thms ->
(binding * typ option * mixfix) list ->
local_theory -> local_theory
val bundle_cmd:
binding * (Facts.ref * Token.src list) list ->
(binding * string option * mixfix) list ->
local_theory -> local_theory
val check: Proof.context -> xstring * Position.T -> string
val context:
string list ->
Element.context_i list ->
generic_theory -> Binding.scope * local_theory
val context_cmd:
(xstring * Position.T) list ->
Element.context list ->
generic_theory -> Binding.scope * local_theory
val get_bundle: Proof.context -> string -> Attrib.thms
val get_bundle_cmd: Proof.context -> xstring * Position.T -> Attrib.thms
val include_: string list -> Proof.state -> Proof.state
val include_cmd:
(xstring * Position.T) list -> Proof.state -> Proof.state
val includes: string list -> Proof.context -> Proof.context
val includes_cmd:
(xstring * Position.T) list -> Proof.context -> Proof.context
val including: string list -> Proof.state -> Proof.state
val including_cmd:
(xstring * Position.T) list -> Proof.state -> Proof.state
val init: binding -> theory -> local_theory
val print_bundles: bool -> Proof.context -> unit
val unbundle: string list -> local_theory -> local_theory
val unbundle_cmd:
(xstring * Position.T) list -> local_theory -> local_theory
end
structure Bundle: BUNDLE
val it = (): unit
signature EXPERIMENT =
sig
val experiment:
Element.context_i list -> theory -> Binding.scope * local_theory
val experiment_cmd:
Element.context list -> theory -> Binding.scope * local_theory
end
structure Experiment: EXPERIMENT
val it = (): unit
signature BASIC_SIMPLIFIER =
sig
val addSSolver: Proof.context * solver -> Proof.context
val addSolver: Proof.context * solver -> Proof.context
val addloop:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val addsimprocs: Proof.context * simproc list -> Proof.context
val addsimps: Proof.context * thm list -> Proof.context
val asm_full_simp_tac: Proof.context -> int -> tactic
val asm_full_simplify: Proof.context -> thm -> thm
val asm_lr_simp_tac: Proof.context -> int -> tactic
val asm_lr_simplify: Proof.context -> thm -> thm
val asm_simp_tac: Proof.context -> int -> tactic
val asm_simplify: Proof.context -> thm -> thm
val cert_simproc:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option}
-> simproc
val clear_simpset: Proof.context -> Proof.context
type cong_name = bool * string
val delloop: Proof.context * string -> Proof.context
val delsimprocs: Proof.context * simproc list -> Proof.context
val delsimps: Proof.context * thm list -> Proof.context
val dest_ss:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val empty_simpset: Proof.context -> Proof.context
val empty_ss: simpset
val eq_rrule: rrule * rrule -> bool
val eq_simproc: simproc * simproc -> bool
val fold_goals_tac: Proof.context -> thm list -> tactic
val fold_rule: Proof.context -> thm list -> thm -> thm
val full_simp_tac: Proof.context -> int -> tactic
val full_simplify: Proof.context -> thm -> thm
val map_theory_simpset:
(Proof.context -> Proof.context) -> theory -> theory
val merge_ss: simpset * simpset -> simpset
val mk_rrules: Proof.context -> thm list -> rrule list
val mk_solver: string -> (Proof.context -> int -> tactic) -> solver
val norm_hhf: Proof.context -> thm -> thm
val norm_hhf_protect: Proof.context -> thm -> thm
type proc
val prune_params_tac: Proof.context -> tactic
val put_simpset: simpset -> Proof.context -> Proof.context
val rewrite_goal_tac: Proof.context -> thm list -> int -> tactic
val rewrite_goals_rule: Proof.context -> thm list -> thm -> thm
val rewrite_goals_tac: Proof.context -> thm list -> tactic
val rewrite_rule: Proof.context -> thm list -> thm -> thm
type rrule
val safe_asm_full_simp_tac: Proof.context -> int -> tactic
val safe_asm_lr_simp_tac: Proof.context -> int -> tactic
val safe_asm_simp_tac: Proof.context -> int -> tactic
val safe_full_simp_tac: Proof.context -> int -> tactic
val safe_simp_tac: Proof.context -> int -> tactic
val setSSolver: Proof.context * solver -> Proof.context
val setSolver: Proof.context * solver -> Proof.context
val setloop:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val simp_debug: bool Config.T
val simp_depth_limit: int Config.T
val simp_tac: Proof.context -> int -> tactic
val simp_trace: bool Config.T
val simp_trace_depth_limit: int Config.T
val simplify: Proof.context -> thm -> thm
type simproc
type simpset
val simpset_map:
Proof.context ->
(Proof.context -> Proof.context) -> simpset -> simpset
val simpset_of: Proof.context -> simpset
type solver
val transform_simproc: morphism -> simproc -> simproc
end
signature SIMPLIFIER =
sig
val addSSolver: Proof.context * solver -> Proof.context
val addSolver: Proof.context * solver -> Proof.context
val add_cong: thm -> Proof.context -> Proof.context
val add_eqcong: thm -> Proof.context -> Proof.context
val add_prems: thm list -> Proof.context -> Proof.context
val add_simp: thm -> Proof.context -> Proof.context
val addloop:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val addsimprocs: Proof.context * simproc list -> Proof.context
val addsimps: Proof.context * thm list -> Proof.context
val asm_full_rewrite: Proof.context -> conv
val asm_full_simp_tac: Proof.context -> int -> tactic
val asm_full_simplify: Proof.context -> thm -> thm
val asm_lr_rewrite: Proof.context -> conv
val asm_lr_simp_tac: Proof.context -> int -> tactic
val asm_lr_simplify: Proof.context -> thm -> thm
val asm_rewrite: Proof.context -> conv
val asm_simp_tac: Proof.context -> int -> tactic
val asm_simplify: Proof.context -> thm -> thm
val attrib: (thm -> Proof.context -> Proof.context) -> attribute
val cert_simproc:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option}
-> simproc
val check_simproc: Proof.context -> xstring * Position.T -> string
val clear_simpset: Proof.context -> Proof.context
val cong_add: attribute
val cong_del: attribute
val cong_modifiers: Method.modifier parser list
type cong_name = bool * string
val default_mk_sym: Proof.context -> thm -> thm option
val define_simproc:
binding -> term simproc_spec -> local_theory -> local_theory
val define_simproc_cmd:
binding -> string simproc_spec -> local_theory -> local_theory
val del_cong: thm -> Proof.context -> Proof.context
val del_eqcong: thm -> Proof.context -> Proof.context
val del_simp: thm -> Proof.context -> Proof.context
val delloop: Proof.context * string -> Proof.context
val delsimprocs: Proof.context * simproc list -> Proof.context
val delsimps: Proof.context * thm list -> Proof.context
val dest_ss:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val empty_simpset: Proof.context -> Proof.context
val empty_ss: simpset
val eq_rrule: rrule * rrule -> bool
val eq_simproc: simproc * simproc -> bool
val fold_goals_tac: Proof.context -> thm list -> tactic
val fold_rule: Proof.context -> thm list -> thm -> thm
val full_rewrite: Proof.context -> conv
val full_simp_tac: Proof.context -> int -> tactic
val full_simplify: Proof.context -> thm -> thm
val init_simpset: thm list -> Proof.context -> Proof.context
val make_simproc:
Proof.context -> string -> term simproc_spec -> simproc
val map_ss:
(Proof.context -> Proof.context) ->
Context.generic -> Context.generic
val map_theory_simpset:
(Proof.context -> Proof.context) -> theory -> theory
val merge_ss: simpset * simpset -> simpset
val method_setup: Method.modifier parser list -> theory -> theory
val mk_rrules: Proof.context -> thm list -> rrule list
val mk_solver: string -> (Proof.context -> int -> tactic) -> solver
val mksimps: Proof.context -> thm -> thm list
val norm_hhf: Proof.context -> thm -> thm
val norm_hhf_protect: Proof.context -> thm -> thm
val prems_of: Proof.context -> thm list
val pretty_simpset: bool -> Proof.context -> Pretty.T
type proc
val prune_params_tac: Proof.context -> tactic
val put_simpset: simpset -> Proof.context -> Proof.context
val rewrite: Proof.context -> conv
val rewrite_goal_tac: Proof.context -> thm list -> int -> tactic
val rewrite_goals_rule: Proof.context -> thm list -> thm -> thm
val rewrite_goals_tac: Proof.context -> thm list -> tactic
val rewrite_rule: Proof.context -> thm list -> thm -> thm
type rrule
val safe_asm_full_simp_tac: Proof.context -> int -> tactic
val safe_asm_lr_simp_tac: Proof.context -> int -> tactic
val safe_asm_simp_tac: Proof.context -> int -> tactic
val safe_full_simp_tac: Proof.context -> int -> tactic
val safe_simp_tac: Proof.context -> int -> tactic
val safe_solver: solver
val safe_solver_tac: Proof.context -> int -> tactic
val setSSolver: Proof.context * solver -> Proof.context
val setSolver: Proof.context * solver -> Proof.context
val set_mkcong:
(Proof.context -> thm -> thm) -> Proof.context -> Proof.context
val set_mkeqTrue:
(Proof.context -> thm -> thm option) ->
Proof.context -> Proof.context
val set_mksimps:
(Proof.context -> thm -> thm list) -> Proof.context -> Proof.context
val set_mksym:
(Proof.context -> thm -> thm option) ->
Proof.context -> Proof.context
val set_subgoaler:
(Proof.context -> int -> tactic) -> Proof.context -> Proof.context
val set_termless:
(term * term -> bool) -> Proof.context -> Proof.context
val set_trace_ops: trace_ops -> theory -> theory
val setloop:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val simp_add: attribute
val simp_debug: bool Config.T
val simp_del: attribute
val simp_depth_limit: int Config.T
val simp_modifiers: Method.modifier parser list
val simp_modifiers': Method.modifier parser list
val simp_tac: Proof.context -> int -> tactic
val simp_trace: bool Config.T
val simp_trace_depth_limit: int Config.T
val simplify: Proof.context -> thm -> thm
type simproc
type 'a simproc_spec =
{lhss: 'a list,
proc: morphism -> Proof.context -> cterm -> thm option}
type simpset
val simpset_map:
Proof.context ->
(Proof.context -> Proof.context) -> simpset -> simpset
val simpset_of: Proof.context -> simpset
type solver
val the_simproc: Proof.context -> string -> simproc
type trace_ops
val transform_simproc: morphism -> simproc -> simproc
val unsafe_solver: solver
val unsafe_solver_tac: Proof.context -> int -> tactic
end
structure Simplifier: SIMPLIFIER
structure Basic_Simplifier: BASIC_SIMPLIFIER
type simproc
type rrule =
{elhs: cterm,
extra: bool, fo: bool, lhs: term, name: string, perm: bool, thm: thm}
type solver
type cong_name = bool * string
type proc
type simpset
val transform_simproc = fn: morphism -> simproc -> simproc
val rewrite_rule = fn: Proof.context -> thm list -> thm -> thm
val rewrite_goals_rule = fn: Proof.context -> thm list -> thm -> thm
val empty_ss =
Simpset
({depth = (0, ref false), prems = [], rules = Leaf []},
{congs = ([], []), loop_tacs = [], mk_rews =
{mk = fn, mk_cong = fn, mk_eq_True = fn, mk_sym = fn, reorient = fn},
procs = Leaf [], solvers = ([], []), subgoal_tac = fn, termless =
fn}):
simpset
val setSSolver = fn: Proof.context * solver -> Proof.context
val simpset_map = fn:
Proof.context -> (Proof.context -> Proof.context) -> simpset -> simpset
val setloop = fn:
Proof.context * (Proof.context -> int -> tactic) -> Proof.context
val clear_simpset = fn: Proof.context -> Proof.context
val full_simp_tac = fn: Proof.context -> int -> tactic
val safe_asm_full_simp_tac = fn: Proof.context -> int -> tactic
val cert_simproc = fn:
theory ->
string ->
{lhss: term list,
proc: morphism -> Proof.context -> cterm -> thm option}
-> simproc
val full_simplify = fn: Proof.context -> thm -> thm
val rewrite_goal_tac = fn: Proof.context -> thm list -> int -> tactic
val asm_full_simp_tac = fn: Proof.context -> int -> tactic
val asm_lr_simp_tac = fn: Proof.context -> int -> tactic
val safe_full_simp_tac = fn: Proof.context -> int -> tactic
val simpset_of = fn: Proof.context -> simpset
val asm_lr_simplify = fn: Proof.context -> thm -> thm
val simplify = fn: Proof.context -> thm -> thm
val asm_full_simplify = fn: Proof.context -> thm -> thm
val simp_trace_depth_limit =
Config
{get_value = fn, map_value = fn, name = "simp_trace_depth_limit", pos =
{line=396, file=raw_simplifier.ML}}:
int Config.T
val asm_simplify = fn: Proof.context -> thm -> thm
val eq_simproc = fn: simproc * simproc -> bool
val map_theory_simpset = fn:
(Proof.context -> Proof.context) -> theory -> theory
val prune_params_tac = fn: Proof.context -> tactic
val empty_simpset = fn: Proof.context -> Proof.context
val asm_simp_tac = fn: Proof.context -> int -> tactic
val simp_trace =
Config
{get_value = fn, map_value = fn, name = "simp_trace", pos =
{line=418, file=raw_simplifier.ML}}:
bool Config.T
val dest_ss = fn:
simpset ->
{congs: (cong_name * thm) list,
loopers: string list,
procs: (string * term list) list,
safe_solvers: string list,
simps: (string * thm) list,
unsafe_solvers: string list, weak_congs: cong_name list}
val mk_solver = fn: string -> (Proof.context -> int -> tactic) -> solver
val rewrite_goals_tac = fn: Proof.context -> thm list -> tactic
val norm_hhf = fn: Proof.context -> thm -> thm
val addSolver = fn: Proof.context * solver -> Proof.context
val safe_simp_tac = fn: Proof.context -> int -> tactic
val simp_depth_limit =
Config
{get_value = fn, map_value = fn, name = "simp_depth_limit", pos =
{line=392, file=raw_simplifier.ML}}:
int Config.T
val merge_ss = fn: simpset * simpset -> simpset
val put_simpset = fn: simpset -> Proof.context -> Proof.context
val simp_tac = fn: Proof.context -> int -> tactic
val setSolver = fn: Proof.context * solver -> Proof.context
val norm_hhf_protect = fn: Proof.context -> thm -> thm
val addsimps = fn: Proof.context * thm list -> Proof.context
val addsimprocs = fn: Proof.context * simproc list -> Proof.context
val delsimps = fn: Proof.context * thm list -> Proof.context
val delsimprocs = fn: Proof.context * simproc list -> Proof.context
val simp_debug =
Config
{get_value = fn, map_value = fn, name = "simp_debug", pos =
{line=415, file=raw_simplifier.ML}}:
bool Config.T
val safe_asm_lr_simp_tac = fn: Proof.context -> int -> tactic
val safe_asm_simp_tac = fn: Proof.context -> int -> tactic
val delloop = fn: Proof.context * string -> Proof.context
val mk_rrules = fn: Proof.context -> thm list -> rrule list
val addSSolver = fn: Proof.context * solver -> Proof.context
val eq_rrule = fn: rrule * rrule -> bool
val addloop = fn:
Proof.context * (string * (Proof.context -> int -> tactic)) ->
Proof.context
val fold_rule = fn: Proof.context -> thm list -> thm -> thm
val fold_goals_tac = fn: Proof.context -> thm list -> tactic
val it = (): unit
signature PLUGIN_NAME =
sig
val check: Proof.context -> xstring * Position.T -> string
val declare: binding -> theory -> string * theory
val declare_setup: binding -> string
val default_filter: filter
val define: binding -> string list -> theory -> string * theory
val define_setup: binding -> string list -> string
type filter = string -> bool
val make_filter: Proof.context -> (Proof.context -> filter) -> filter
val parse_filter: (Proof.context -> filter) parser
end
structure Plugin_Name: PLUGIN_NAME
signature PLUGIN =
sig
type T
val data: Plugin_Name.filter -> T -> local_theory -> local_theory
val data_default: T -> local_theory -> local_theory
val interpretation:
string -> (T -> local_theory -> local_theory) -> theory -> theory
end
functor Plugin (sig type T end): PLUGIN
val it = (): unit
### ML warning (line 116 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 180 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 194 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 198 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 333 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 624 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 640 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 873 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 874 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1142 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1143 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1149 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1151 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1152 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1161 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1225 of "Isar/code.ML"):
### Matches are not exhaustive.
### ML warning (line 1473 of "Isar/code.ML"):
### Pattern is not exhaustive.
### ML warning (line 1556 of "Isar/code.ML"):
### Matches are not exhaustive.
signature CODE =
sig
type abs_type
val abstype_interpretation:
(string * abs_type -> theory -> theory) -> theory -> theory
val add_eqn_global: thm * bool -> theory -> theory
val args_number: theory -> string -> int
val assert_abs_eqn:
theory -> string option -> thm -> thm * (string * string)
val assert_eqn: theory -> thm * bool -> thm * bool
type case_schema
type cert
val check_const: theory -> term -> string
val conclude_cert: cert -> cert
val constrain_cert: theory -> sort list -> cert -> cert
val constrset_of_consts:
theory ->
(string * typ) list ->
string *
((string * sort) list *
(string * ((string * sort) list * typ list)) list)
type constructors
val datatype_interpretation:
(string * constructors -> theory -> theory) -> theory -> theory
val declare_aborting_global: string -> theory -> theory
val declare_abstract_eqn: thm -> local_theory -> local_theory
val declare_abstract_eqn_global: thm -> theory -> theory
val declare_abstype: thm -> local_theory -> local_theory
val declare_abstype_global: thm -> theory -> theory
val declare_case_global: thm -> theory -> theory
val declare_datatype_cmd: string list -> theory -> theory
val declare_datatype_global: (string * typ) list -> theory -> theory
val declare_default_eqns:
(thm * bool) list -> local_theory -> local_theory
val declare_default_eqns_global: (thm * bool) list -> theory -> theory
val declare_eqns: (thm * bool) list -> local_theory -> local_theory
val declare_eqns_global: (thm * bool) list -> theory -> theory
val declare_undefined_global: string -> theory -> theory
val declare_unimplemented_global: string -> theory -> theory
val del_eqn_global: thm -> theory -> theory
val equations_of_cert:
theory ->
cert ->
((string * sort) list * typ) *
(((term * string option) list * (term * string option)) *
(thm option * bool)
)
list
option
val get_case_cong: theory -> string -> thm option
val get_case_schema: theory -> string -> case_schema option
val get_cert:
Proof.context ->
((thm * bool) list -> (thm * bool) list option) list ->
string -> cert
val get_type: theory -> string -> constructors * bool
val get_type_of_constr_or_abstr:
theory -> string -> (string * bool) option
val is_abstr: theory -> string -> bool
val is_constr: theory -> string -> bool
val is_undefined: theory -> string -> bool
val pretty_cert: theory -> cert -> Pretty.T list
val print_codesetup: theory -> unit
val read_const: theory -> string -> string
val string_of_const: theory -> string -> string
val typargs_deps_of_cert:
theory -> cert -> (string * sort) list * (string * typ list) list
val type_interpretation:
(string -> theory -> theory) -> theory -> theory
end
signature CODE_DATA_ARGS = sig type T val empty: T end
signature CODE_DATA =
sig
type T
val change: theory option -> (T -> T) -> T
val change_yield: theory option -> (T -> 'a * T) -> 'a * T
end
signature PRIVATE_CODE =
sig
type abs_type
val abstype_interpretation:
(string * abs_type -> theory -> theory) -> theory -> theory
val add_eqn_global: thm * bool -> theory -> theory
val args_number: theory -> string -> int
val assert_abs_eqn:
theory -> string option -> thm -> thm * (string * string)
val assert_eqn: theory -> thm * bool -> thm * bool
type case_schema
type cert
val change_yield_data:
serial * ('a -> exn) * (exn -> 'a) ->
theory -> ('a -> 'b * 'a) -> 'b * 'a
val check_const: theory -> term -> string
val conclude_cert: cert -> cert
val constrain_cert: theory -> sort list -> cert -> cert
val constrset_of_consts:
theory ->
(string * typ) list ->
string *
((string * sort) list *
(string * ((string * sort) list * typ list)) list)
type constructors
val datatype_interpretation:
(string * constructors -> theory -> theory) -> theory -> theory
val declare_aborting_global: string -> theory -> theory
val declare_abstract_eqn: thm -> local_theory -> local_theory
val declare_abstract_eqn_global: thm -> theory -> theory
val declare_abstype: thm -> local_theory -> local_theory
val declare_abstype_global: thm -> theory -> theory
val declare_case_global: thm -> theory -> theory
val declare_data: exn -> serial
val declare_datatype_cmd: string list -> theory -> theory
val declare_datatype_global: (string * typ) list -> theory -> theory
val declare_default_eqns:
(thm * bool) list -> local_theory -> local_theory
val declare_default_eqns_global: (thm * bool) list -> theory -> theory
val declare_eqns: (thm * bool) list -> local_theory -> local_theory
val declare_eqns_global: (thm * bool) list -> theory -> theory
val declare_undefined_global: string -> theory -> theory
val declare_unimplemented_global: string -> theory -> theory
val del_eqn_global: thm -> theory -> theory
val equations_of_cert:
theory ->
cert ->
((string * sort) list * typ) *
(((term * string option) list * (term * string option)) *
(thm option * bool)
)
list
option
val get_case_cong: theory -> string -> thm option
val get_case_schema: theory -> string -> case_schema option
val get_cert:
Proof.context ->
((thm * bool) list -> (thm * bool) list option) list ->
string -> cert
val get_type: theory -> string -> constructors * bool
val get_type_of_constr_or_abstr:
theory -> string -> (string * bool) option
val is_abstr: theory -> string -> bool
val is_constr: theory -> string -> bool
val is_undefined: theory -> string -> bool
val pretty_cert: theory -> cert -> Pretty.T list
val print_codesetup: theory -> unit
val read_const: theory -> string -> string
val string_of_const: theory -> string -> string
val typargs_deps_of_cert:
theory -> cert -> (string * sort) list * (string * typ list) list
val type_interpretation:
(string -> theory -> theory) -> theory -> theory
end
structure Code: PRIVATE_CODE
functor Code_Data (Data: CODE_DATA_ARGS): CODE_DATA
structure Code: CODE
val it = (): unit
signature SPEC_RULES =
sig
val add:
rough_classification ->
term list * thm list -> local_theory -> local_theory
val add_global:
rough_classification -> term list * thm list -> theory -> theory
val get: Proof.context -> spec list
val get_global: theory -> spec list
val retrieve: Proof.context -> term -> spec list
val retrieve_global: theory -> term -> spec list
datatype rough_classification
= Co_Inductive | Equational | Inductive | Unknown
type spec = rough_classification * (term list * thm list)
end
structure Spec_Rules: SPEC_RULES
val it = (): unit
### ML warning (line 154 of "Isar/specification.ML"):
### Pattern is not exhaustive.
### ML warning (line 172 of "Isar/specification.ML"):
### Matches are not exhaustive.
### ML warning (line 207 of "Isar/specification.ML"):
### Pattern is not exhaustive.
### ML warning (line 255 of "Isar/specification.ML"):
### Matches are not exhaustive.
### ML warning (line 268 of "Isar/specification.ML"):
### Pattern is not exhaustive.
### ML warning (line 298 of "Isar/specification.ML"):
### Matches are not exhaustive.
### ML warning (line 406 of "Isar/specification.ML"):
### Pattern is not exhaustive.
### ML warning (line 441 of "Isar/specification.ML"):
### Pattern is not exhaustive.
signature SPECIFICATION =
sig
val abbreviation:
Syntax.mode ->
(binding * typ option * mixfix) option ->
(binding * typ option * mixfix) list ->
term -> bool -> local_theory -> local_theory
val abbreviation_cmd:
Syntax.mode ->
(binding * string option * mixfix) option ->
(binding * string option * mixfix) list ->
string -> bool -> local_theory -> local_theory
val alias: binding * string -> local_theory -> local_theory
val alias_cmd:
binding * (xstring * Position.T) -> local_theory -> local_theory
val axiom: Attrib.binding * term -> theory -> thm * theory
val axiomatization:
(binding * typ option * mixfix) list ->
(binding * typ option * mixfix) list ->
term list ->
(Attrib.binding * term) list ->
theory -> (term list * thm list) * theory
val axiomatization_cmd:
(binding * string option * mixfix) list ->
(binding * string option * mixfix) list ->
string list ->
(Attrib.binding * string) list ->
theory -> (term list * thm list) * theory
val check_multi_specs:
(binding * typ option * mixfix) list ->
multi_specs ->
Proof.context ->
(((binding * typ) * mixfix) list *
(Attrib.binding * term) list)
*
Proof.context
val check_spec_open:
(binding * typ option * mixfix) list ->
(binding * typ option * mixfix) list ->
term list ->
term ->
Proof.context ->
((binding * typ option * mixfix) list * string list *
(string -> Position.T list) * term)
*
Proof.context
val definition:
(binding * typ option * mixfix) option ->
(binding * typ option * mixfix) list ->
term list ->
Attrib.binding * term ->
local_theory -> (term * (string * thm)) * local_theory
val definition':
(binding * typ option * mixfix) option ->
(binding * typ option * mixfix) list ->
term list ->
Attrib.binding * term ->
bool ->
local_theory -> (term * (string * thm)) * local_theory
val definition_cmd:
(binding * string option * mixfix) option ->
(binding * string option * mixfix) list ->
string list ->
Attrib.binding * string ->
bool ->
local_theory -> (term * (string * thm)) * local_theory
type multi_specs =
((Attrib.binding * term) * term list *
(binding * typ option * mixfix) list
)
list
type multi_specs_cmd =
((Attrib.binding * string) * string list *
(binding * string option * mixfix) list
)
list
val notation:
bool ->
Syntax.mode -> (term * mixfix) list -> local_theory -> local_theory
val notation_cmd:
bool ->
Syntax.mode ->
(string * mixfix) list -> local_theory -> local_theory
val read_multi_specs:
(binding * string option * mixfix) list ->
multi_specs_cmd ->
Proof.context ->
(((binding * typ) * mixfix) list *
(Attrib.binding * term) list)
*
Proof.context
val read_props:
string list ->
(binding * string option * mixfix) list ->
Proof.context -> term list * Proof.context
val read_spec_open:
(binding * string option * mixfix) list ->
(binding * string option * mixfix) list ->
string list ->
string ->
Proof.context ->
((binding * typ option * mixfix) list * string list *
(string -> Position.T list) * term)
*
Proof.context
val schematic_theorem:
bool ->
string ->
Method.text option ->
(thm list list -> local_theory -> local_theory) ->
Attrib.binding ->
string list ->
Element.context_i list ->
Element.statement_i ->
bool -> local_theory -> Proof.state
val schematic_theorem_cmd:
bool ->
string ->
Method.text option ->
(thm list list -> local_theory -> local_theory) ->
Attrib.binding ->
(xstring * Position.T) list ->
Element.context list ->
Element.statement ->
bool -> local_theory -> Proof.state
val theorem:
bool ->
string ->
Method.text option ->
(thm list list -> local_theory -> local_theory) ->
Attrib.binding ->
string list ->
Element.context_i list ->
Element.statement_i ->
bool -> local_theory -> Proof.state
val theorem_cmd:
bool ->
string ->
Method.text option ->
(thm list list -> local_theory -> local_theory) ->
Attrib.binding ->
(xstring * Position.T) list ->
Element.context list ->
Element.statement ->
bool -> local_theory -> Proof.state
val theorems:
string ->
(Attrib.binding * Attrib.thms) list ->
(binding * typ option * mixfix) list ->
bool -> local_theory -> (string * thm list) list * local_theory
val theorems_cmd:
string ->
(Attrib.binding * (Facts.ref * Token.src list) list) list ->
(binding * string option * mixfix) list ->
bool -> local_theory -> (string * thm list) list * local_theory
val type_alias: binding * string -> local_theory -> local_theory
val type_alias_cmd:
binding * (xstring * Position.T) -> local_theory -> local_theory
val type_notation:
bool ->
Syntax.mode -> (typ * mixfix) list -> local_theory -> local_theory
val type_notation_cmd:
bool ->
Syntax.mode ->
(string * mixfix) list -> local_theory -> local_theory
end
structure Specification: SPECIFICATION
val it = (): unit
signature PARSE_SPEC =
sig
val class_expression: string list parser
val cond_statement:
(bool * (Attrib.binding * (string * string list) list) list) parser
val constdecl: (binding * string option * mixfix) parser
val context_element: Element.context parser
val if_assumes: string list parser
val if_statement:
(Attrib.binding * (string * string list) list) list parser
val if_statement': (string * string list) list list parser
val includes: (xstring * Position.T) list parser
val locale_expression: Expression.expression parser
val locale_fixes: (binding * string option * mixfix) list parser
val locale_insts:
(string option list * (Attrib.binding * string) list) parser
val locale_keyword: string parser
val locale_prefix: (string * bool) parser
val long_statement: (Element.context list * Element.statement) parser
val long_statement_keyword: string parser
val multi_specs: Specification.multi_specs_cmd parser
val name_facts:
(Attrib.binding * (Facts.ref * Token.src list) list) list parser
val obtains: Element.obtains parser
val opt_thm_name: string -> Attrib.binding parser
val overloaded: bool parser
val simple_spec: (Attrib.binding * string) parser
val simple_specs: (Attrib.binding * string list) parser
val specification:
((binding * string option * mixfix) list *
Specification.multi_specs_cmd
)
parser
val statement:
(Attrib.binding * (string * string list) list) list parser
val statement': (string * string list) list list parser
val thm_name: string -> Attrib.binding parser
val where_multi_specs: Specification.multi_specs_cmd parser
end
structure Parse_Spec: PARSE_SPEC
val it = (): unit
### ML warning (line 102 of "Isar/typedecl.ML"):
### Pattern is not exhaustive.
signature TYPEDECL =
sig
val abbrev:
binding * string list * mixfix ->
typ -> local_theory -> string * local_theory
val abbrev_cmd:
binding * string list * mixfix ->
string -> local_theory -> string * local_theory
val abbrev_global:
binding * string list * mixfix -> typ -> theory -> string * theory
val basic_typedecl:
{final: bool} ->
binding * int * mixfix -> local_theory -> string * local_theory
val read_constraint: Proof.context -> string option -> sort
val typedecl:
{final: bool} ->
binding * (string * sort) list * mixfix ->
local_theory -> typ * local_theory
val typedecl_global:
{final: bool} ->
binding * (string * sort) list * mixfix -> theory -> typ * theory
end
structure Typedecl: TYPEDECL
val it = (): unit
signature PROOF_NODE =
sig
type T
val apply: (Proof.state -> Proof.state) -> T -> T
val applys: (Proof.state -> Proof.state Seq.result Seq.seq) -> T -> T
val back: T -> T
val current: T -> Proof.state
val init: Proof.state -> T
val position: T -> int
end
structure Proof_Node: PROOF_NODE
val it = (): unit
### ML warning (line 232 of "Isar/toplevel.ML"):
### Handler catches all exceptions.
### ML warning (line 271 of "Isar/toplevel.ML"):
### Handler catches all exceptions.
### ML warning (line 279 of "Isar/toplevel.ML"):
### Handler catches all exceptions.
### ML warning (line 699 of "Isar/toplevel.ML"):
### Pattern is not exhaustive.
signature TOPLEVEL =
sig
exception UNDEF
val actual_proof:
(Proof_Node.T -> Proof_Node.T) -> transition -> transition
val add_hook: (transition -> state -> state -> unit) -> unit
val begin_local_theory:
bool -> (theory -> local_theory) -> transition -> transition
val close_target: transition -> transition
val command_errors:
bool -> transition -> state -> Runtime.error list * state option
val command_exception: bool -> transition -> state -> state
val context_of: state -> Proof.context
val element_result:
Keyword.keywords ->
transition Thy_Syntax.element -> state -> result * state
val empty: transition
val end_local_theory: transition -> transition
val end_proof:
(bool -> Proof.state -> Proof.context) -> transition -> transition
val end_theory: Position.T -> state -> theory
val exec_id: int -> transition -> transition
val exit: transition -> transition
val forget_proof: bool -> transition -> transition
val generic_theory:
(generic_theory -> generic_theory) -> transition -> transition
val generic_theory_of: state -> generic_theory
val get_timing: transition -> Time.time
val ignored: Position.T -> transition
val init_theory: (unit -> theory) -> transition -> transition
val is_ignored: transition -> bool
val is_init: transition -> bool
val is_proof: state -> bool
val is_skipped_proof: state -> bool
val is_theory: state -> bool
val is_toplevel: state -> bool
val join_results: result -> (transition * state) list
val keep: (state -> unit) -> transition -> transition
val keep': (bool -> state -> unit) -> transition -> transition
val keep_proof: (state -> unit) -> transition -> transition
val level: state -> int
val local_theory:
(bool * Position.T) option ->
(xstring * Position.T) option ->
(local_theory -> local_theory) -> transition -> transition
val local_theory':
(bool * Position.T) option ->
(xstring * Position.T) option ->
(bool -> local_theory -> local_theory) ->
transition -> transition
val local_theory_to_proof:
(bool * Position.T) option ->
(xstring * Position.T) option ->
(local_theory -> Proof.state) -> transition -> transition
val local_theory_to_proof':
(bool * Position.T) option ->
(xstring * Position.T) option ->
(bool -> local_theory -> Proof.state) -> transition -> transition
val malformed: Position.T -> string -> transition
val modify_init: (unit -> theory) -> transition -> transition
val name: string -> transition -> transition
val name_of: transition -> string
val open_target:
(generic_theory -> local_theory) -> transition -> transition
val pos_of: transition -> Position.T
val position: Position.T -> transition -> transition
val present_local_theory:
(xstring * Position.T) option ->
(state -> unit) -> transition -> transition
val presentation_context_of: state -> Proof.context
val pretty_abstract: state -> Pretty.T
val pretty_context: state -> Pretty.T list
val pretty_state: state -> Pretty.T list
val previous_context_of: state -> Proof.context option
val proof: (Proof.state -> Proof.state) -> transition -> transition
val proof':
(bool -> Proof.state -> Proof.state) -> transition -> transition
val proof_of: state -> Proof.state
val proof_position_of: state -> int
val proofs:
(Proof.state -> Proof.state Seq.result Seq.seq) ->
transition -> transition
val proofs':
(bool -> Proof.state -> Proof.state Seq.result Seq.seq) ->
transition -> transition
val put_timing: Time.time -> transition -> transition
val reset_proof: state -> state option
val reset_theory: state -> state option
type result
val setmp_thread_position: transition -> ('a -> 'b) -> 'a -> 'b
val skip_proof: (unit -> unit) -> transition -> transition
val skip_proof_close: transition -> transition
val skip_proof_open: transition -> transition
type state
val string_of_state: state -> string
val theory: (theory -> theory) -> transition -> transition
val theory': (bool -> theory -> theory) -> transition -> transition
val theory_of: state -> theory
val theory_to_proof: (theory -> Proof.state) -> transition -> transition
val theory_toplevel: theory -> state
val toplevel: state
val transition:
bool -> transition -> state -> state * (exn * string) option
type transition
val type_error: transition -> string
end
structure Toplevel: TOPLEVEL
val it = (): unit
### ML warning (line 95 of "Proof/reconstruct.ML"):
### Value identifier (ctxt) has not been referenced.
### ML warning (line 79 of "Proof/reconstruct.ML"):
### Value identifier (vTs) has not been referenced.
### ML warning (line 79 of "Proof/reconstruct.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 79 of "Proof/reconstruct.ML"):
### Value identifier (env) has not been referenced.
### ML warning (line 79 of "Proof/reconstruct.ML"):
### Value identifier (ctxt) has not been referenced.
### ML warning (line 72 of "Proof/reconstruct.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 72 of "Proof/reconstruct.ML"):
### Value identifier (ctxt) has not been referenced.
### ML warning (line 62 of "Proof/reconstruct.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 261 of "Proof/reconstruct.ML"):
### Value identifier (env) has not been referenced.
### ML warning (line 292 of "Proof/reconstruct.ML"):
### Pattern is not exhaustive.
### ML warning (line 328 of "Proof/reconstruct.ML"):
### Value identifier (Hs) has not been referenced.
### ML warning (line 327 of "Proof/reconstruct.ML"):
### Value identifier (Hs) has not been referenced.
### ML warning (line 326 of "Proof/reconstruct.ML"):
### Value identifier (Hs) has not been referenced.
### ML warning (line 325 of "Proof/reconstruct.ML"):
### Value identifier (Hs) has not been referenced.
### ML warning (line 324 of "Proof/reconstruct.ML"):
### Value identifier (Hs) has not been referenced.
### ML warning (line 321 of "Proof/reconstruct.ML"):
### Value identifier (prf2) has not been referenced.
### ML warning (line 316 of "Proof/reconstruct.ML"):
### Value identifier (s) has not been referenced.
### ML warning (line 322 of "Proof/reconstruct.ML"):
### Value identifier (P) has not been referenced.
signature RECONSTRUCT =
sig
val clean_proof_of: Proof.context -> bool -> thm -> proof
val expand_proof:
Proof.context -> (string * term option) list -> proof -> proof
val proof_of: Proof.context -> thm -> proof
val prop_of: proof -> term
val prop_of': term list -> proof -> term
val quiet_mode: bool Config.T
val reconstruct_proof: Proof.context -> term -> proof -> proof
end
structure Reconstruct: RECONSTRUCT
val it = (): unit
### ML warning (line 129 of "Proof/proof_syntax.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 128 of "Proof/proof_syntax.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 191 of "Proof/proof_syntax.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 190 of "Proof/proof_syntax.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 189 of "Proof/proof_syntax.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 163 of "Proof/proof_syntax.ML"):
### Matches are not exhaustive.
signature PROOF_SYNTAX =
sig
val add_proof_syntax: theory -> theory
val cterm_of_proof: theory -> proof -> cterm * (cterm -> proof)
val pretty_clean_proof_of: Proof.context -> bool -> thm -> Pretty.T
val pretty_proof: Proof.context -> proof -> Pretty.T
val proofT: typ
val proof_of: Proof.context -> bool -> thm -> proof
val proof_of_term: theory -> bool -> term -> proof
val proof_syntax: proof -> theory -> theory
val read_proof: theory -> bool -> bool -> string -> proof
val read_term: theory -> bool -> typ -> string -> term
val term_of_proof: proof -> term
end
structure Proof_Syntax: PROOF_SYNTAX
val it = (): unit
### ML warning (line 28 of "Proof/proof_rewrite_rules.ML"):
### Matches are not exhaustive.
### ML warning (line 31 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 69 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 70 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 84 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 85 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 98 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 99 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 111 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 112 of "Proof/proof_rewrite_rules.ML"):
### Pattern is not exhaustive.
### ML warning (line 205 of "Proof/proof_rewrite_rules.ML"):
### Matches are not exhaustive.
### ML warning (line 351 of "Proof/proof_rewrite_rules.ML"):
### Matches are not exhaustive.
### ML warning (line 370 of "Proof/proof_rewrite_rules.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 370 of "Proof/proof_rewrite_rules.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 370 of "Proof/proof_rewrite_rules.ML"):
### Value identifier (ctxt) has not been referenced.
### ML warning (line 367 of "Proof/proof_rewrite_rules.ML"):
### Value identifier (Ts) has not been referenced.
signature PROOF_REWRITE_RULES =
sig
val elim_defs: Proof.context -> bool -> thm list -> proof -> proof
val elim_vars: (typ -> term) -> proof -> proof
val expand_of_class:
Proof.context ->
typ list -> term option list -> proof -> (proof * proof) option
val hhf_proof: term -> term -> proof -> proof
val mk_of_sort_proof:
Proof.context -> term option list -> typ * sort -> proof list
val rew:
bool ->
typ list -> term option list -> proof -> (proof * proof) option
val rewrite_terms: (term -> term) -> proof -> proof
val rprocs:
bool ->
(typ list -> term option list -> proof -> (proof * proof) option)
list
val un_hhf_proof: term -> term -> proof -> proof
end
structure ProofRewriteRules: PROOF_REWRITE_RULES
val it = (): unit
signature PROOF_CHECKER = sig val thm_of_proof: theory -> proof -> thm end
structure Proof_Checker: PROOF_CHECKER
val it = (): unit
### ML warning (line 329 of "Proof/extraction.ML"):
### Matches are not exhaustive.
### ML warning (line 504 of "Proof/extraction.ML"):
### Matches are not exhaustive.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (defs) has not been referenced.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (vs) has not been referenced.
### ML warning (line 662 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 647 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 647 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 580 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 540 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 534 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (cs) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (vs) has not been referenced.
### ML warning (line 532 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (defs) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (vs) has not been referenced.
### ML warning (line 775 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 763 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 763 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 697 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 686 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 671 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 666 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 664 of "Proof/extraction.ML"):
### Value identifier (hs) has not been referenced.
### ML warning (line 664 of "Proof/extraction.ML"):
### Value identifier (Ts) has not been referenced.
### ML warning (line 664 of "Proof/extraction.ML"):
### Value identifier (ts) has not been referenced.
### ML warning (line 664 of "Proof/extraction.ML"):
### Value identifier (vs) has not been referenced.
### ML warning (line 664 of "Proof/extraction.ML"):
### Value identifier (d) has not been referenced.
### ML warning (line 803 of "Proof/extraction.ML"):
### Matches are not exhaustive.
signature EXTRACTION =
sig
val abs_corr_shyps:
theory -> thm -> string list -> term list -> proof -> proof
val add_expand_thm: bool -> thm -> theory -> theory
val add_realizers:
(thm * (string list * string * string)) list -> theory -> theory
val add_realizers_i:
(string * (string list * term * proof)) list -> theory -> theory
val add_realizes_eqns: string list -> theory -> theory
val add_realizes_eqns_i:
((term * term) list * (term * term)) list -> theory -> theory
val add_typeof_eqns: string list -> theory -> theory
val add_typeof_eqns_i:
((term * term) list * (term * term)) list -> theory -> theory
val add_types:
(xstring *
((term -> term option) list *
(term -> typ -> term -> typ -> term) option)
)
list
-> theory -> theory
val etype_of: theory -> string list -> typ list -> term -> typ
val extract: (thm * string list) list -> theory -> theory
val mk_typ: typ -> term
val nullT: typ
val nullt: term
val realizes_of: theory -> string list -> term -> term -> term
val set_preprocessor: (theory -> proof -> proof) -> theory -> theory
end
structure Extraction: EXTRACTION
val it = (): unit
### ML warning (line 157 of "System/bash.ML"):
### Handler catches all exceptions.
### ML warning (line 195 of "System/bash.ML"):
### Matches are not exhaustive.
### ML warning (line 199 of "System/bash.ML"):
### Handler catches all exceptions.
structure Bash: BASH
signature BASH =
sig
val process:
string ->
{err: string, out: string, rc: int, terminate: unit -> unit}
val string: string -> string
val strings: string list -> string
end
val it = (): unit
val it = (): unit
signature ISABELLE_SYSTEM =
sig
val bash: string -> int
val bash_output: string -> string * int
val copy_dir: Path.T -> Path.T -> unit
val copy_file: Path.T -> Path.T -> unit
val copy_file_base: Path.T * Path.T -> Path.T -> unit
val create_tmp_path: string -> string -> Path.T
val mkdir: Path.T -> unit
val mkdirs: Path.T -> unit
val rm_tree: Path.T -> unit
val with_tmp_dir: string -> (Path.T -> 'a) -> 'a
val with_tmp_file: string -> string -> (Path.T -> 'a) -> 'a
end
structure Isabelle_System: ISABELLE_SYSTEM
val it = (): unit
signature TERM_STYLE =
sig
val parse: (term -> term) context_parser
val setup:
binding -> (Proof.context -> term -> term) parser -> theory -> theory
end
structure Term_Style: TERM_STYLE
val it = (): unit
signature OUTER_SYNTAX =
sig
val bootstrap: bool Config.T
val check_command: Proof.context -> command_keyword -> string
val command:
command_keyword ->
string ->
(Toplevel.transition -> Toplevel.transition) parser -> unit
type command_keyword = string * Position.T
val command_reports: theory -> Token.T -> Position.report_text list
val help: theory -> string list -> unit
val local_theory:
command_keyword ->
string -> (local_theory -> local_theory) parser -> unit
val local_theory':
command_keyword ->
string -> (bool -> local_theory -> local_theory) parser -> unit
val local_theory_to_proof:
command_keyword ->
string -> (local_theory -> Proof.state) parser -> unit
val local_theory_to_proof':
command_keyword ->
string -> (bool -> local_theory -> Proof.state) parser -> unit
val maybe_begin_local_theory:
command_keyword ->
string ->
(local_theory -> local_theory) parser ->
(theory -> local_theory) parser -> unit
val parse: theory -> Position.T -> string -> Toplevel.transition list
val parse_spans: Token.T list -> Command_Span.span list
val parse_tokens: theory -> Token.T list -> Toplevel.transition list
val print_commands: theory -> unit
val side_comments: Token.T list -> Token.T list
end
structure Outer_Syntax: OUTER_SYNTAX
val it = (): unit
### ML warning (line 559 of "Thy/thy_output.ML"):
### Pattern is not exhaustive.
### ML warning (line 584 of "Thy/thy_output.ML"):
### Pattern is not exhaustive.
signature THY_OUTPUT =
sig
val add_option:
binding ->
(string -> Proof.context -> Proof.context) -> theory -> theory
val add_wrapper:
((unit -> string) -> unit -> string) ->
Proof.context -> Proof.context
val antiquotation:
binding ->
'a context_parser ->
({context: Proof.context,
source: Token.src, state: Toplevel.state}
-> 'a -> string)
-> theory -> theory
val boolean: string -> bool
val break: bool Config.T
val check_command: Proof.context -> xstring * Position.T -> string
val check_option: Proof.context -> xstring * Position.T -> string
val display: bool Config.T
val document_command:
{markdown: bool} ->
(xstring * Position.T) option * Input.source ->
Toplevel.transition -> Toplevel.transition
val eval_antiquote: Toplevel.state -> Antiquote.text_antiquote -> string
val indent: int Config.T
val integer: string -> int
val margin: int Config.T
val maybe_pretty_source:
(Proof.context -> 'a -> Pretty.T) ->
Proof.context -> Token.src -> 'a list -> Pretty.T list
val modes: string Config.T
val output: Proof.context -> Pretty.T list -> string
val output_text:
Toplevel.state -> {markdown: bool} -> Input.source -> string
val present_thy:
theory ->
(Toplevel.transition * Toplevel.state) list ->
Token.T list -> Buffer.T
val pretty_term: Proof.context -> term -> Pretty.T
val pretty_text: Proof.context -> string -> Pretty.T
val pretty_thm: Proof.context -> thm -> Pretty.T
val print_antiquotations: bool -> Proof.context -> unit
val quotes: bool Config.T
val source: bool Config.T
val str_of_source: Token.src -> string
val string_of_margin: Proof.context -> Pretty.T -> string
val verbatim_text: Proof.context -> string -> string
end
structure Thy_Output: THY_OUTPUT
val it = (): unit
structure Document_Antiquotations: sig end
val it = (): unit
signature GRAPH_DISPLAY =
sig
val content_node: string -> Pretty.T list -> node
val display_graph: entry list -> unit
val display_graph_old: entry list -> unit
type entry = (string * node) * string list
type node
val session_node:
{directory: string, name: string, path: string, unfold: bool} -> node
end
structure Graph_Display: GRAPH_DISPLAY
val it = (): unit
signature PURE_SYN = sig val bootstrap_thy: theory end
structure Pure_Syn: PURE_SYN
val it = (): unit
### ML warning (line 203 of "PIDE/command.ML"):
### Handler catches all exceptions.
### ML warning (line 295 of "PIDE/command.ML"):
### Handler catches all exceptions.
signature COMMAND =
sig
type blob = (string * (SHA1.digest * string list) option) Exn.result
val eval:
Keyword.keywords ->
Path.T ->
(unit -> theory) ->
blob list * int -> Token.T list -> eval -> eval
type eval
val eval_eq: eval * eval -> bool
val eval_exec_id: eval -> int
val eval_finished: eval -> bool
val eval_result_state: eval -> Toplevel.state
val eval_running: eval -> bool
val exec: int -> exec -> unit
type exec = eval * print list
val exec_ids: exec option -> int list
val init_exec: theory option -> exec
val no_exec: exec
val no_print_function: string -> unit
val print:
bool ->
(string * string list) list ->
Keyword.keywords ->
string -> eval -> print list -> print list option
type print
type print_fn = Toplevel.transition -> Toplevel.state -> unit
val print_function: string -> print_function -> unit
type print_function =
{args: string list,
command_name: string, exec_id: int, keywords: Keyword.keywords}
->
{delay: Time.time option,
persistent: bool, pri: int, print_fn: print_fn, strict: bool}
option
val read:
Keyword.keywords ->
theory ->
Path.T ->
(unit -> theory) ->
blob list * int -> Token.T list -> Toplevel.transition
val read_file: Path.T -> Position.T -> Path.T -> Token.file
val read_thy: Toplevel.state -> theory
end
structure Command: COMMAND
val it = (): unit
signature QUERY_OPERATION =
sig
val register:
{name: string, pri: int} ->
({args: string list,
output_result: string -> unit,
state: Toplevel.state, writeln_result: string -> unit}
-> unit)
-> unit
end
structure Query_Operation: QUERY_OPERATION
val it = (): unit
signature RESOURCES =
sig
val begin_theory: Path.T -> Thy_Header.header -> theory list -> theory
val check_thy:
Path.T ->
string ->
{imports: (string * Position.T) list,
keywords: Thy_Header.keywords,
master: Path.T * SHA1.digest,
text: string, theory_pos: Position.T}
val default_qualifier: string
val finish_session_base: unit -> unit
val global_theory: string -> string option
val import_name:
string ->
Path.T ->
string ->
{master_dir: Path.T, node_name: Path.T, theory_name: string}
val imports_of: theory -> (string * Position.T) list
val init_session_base:
{global_theories: (string * string) list,
known_theories: (string * string) list,
loaded_theories: (string * string) list}
-> unit
val known_theory: string -> Path.T option
val loaded_files_current: theory -> bool
val loaded_theory: string -> string option
val master_directory: theory -> Path.T
val parse_files: string -> (theory -> Token.file list) parser
val provide: Path.T * SHA1.digest -> theory -> theory
val provide_parse_files:
string -> (theory -> Token.file list * theory) parser
val theory_qualifier: string -> string
val thy_path: Path.T -> Path.T
end
structure Resources: RESOURCES
val it = (): unit
signature PRESENT =
sig
val begin_theory: int -> (unit -> string) -> theory -> theory
val display_drafts: Path.T list -> int
val document_enabled: string -> bool
val document_variants: string -> (string * string) list
val finish: unit -> unit
val init:
HTML.symbols ->
bool ->
bool ->
Path.T ->
string ->
string ->
(string * string) list ->
(Path.T * Path.T) list ->
Path.T -> string * string -> bool -> unit
val theory_output: theory -> string -> unit
val theory_qualifier: theory -> string
end
structure Present: PRESENT
val it = (): unit
signature THY_INFO =
sig
val finish: unit -> unit
val get_names: unit -> string list
val get_theory: string -> theory
val lookup_theory: string -> theory option
val master_directory: string -> Path.T
val pure_theory: unit -> theory
val register_thy: theory -> unit
val remove_thy: string -> unit
val script_thy: Position.T -> string -> theory -> theory
val use_theories:
{document: bool,
last_timing: Toplevel.transition -> Time.time,
master_dir: Path.T, qualifier: string, symbols: HTML.symbols}
-> (string * Position.T) list -> unit
val use_thy: string -> unit
end
structure Thy_Info: THY_INFO
val use_thy = fn: string -> unit
val it = (): unit
signature SESSION =
sig
val finish: unit -> unit
val get_keywords: unit -> Keyword.keywords
val get_name: unit -> string
val init:
HTML.symbols ->
bool ->
bool ->
Path.T ->
string ->
string ->
(string * string) list ->
(Path.T * Path.T) list ->
Path.T -> string -> string * string -> bool -> unit
val init_protocol_handlers: unit -> unit
val protocol_handler: string -> unit
val shutdown: unit -> unit
val welcome: unit -> string
end
structure Session: SESSION
val it = (): unit
signature PROTOCOL_MESSAGE =
sig
val command_positions: string -> XML.body -> XML.body
val command_positions_yxml: string -> string -> string
end
structure Protocol_Message: PROTOCOL_MESSAGE
val it = (): unit
### ML warning (line 515 of "PIDE/document.ML"):
### Handler catches all exceptions.
signature DOCUMENT =
sig
type blob_digest = (string * string option) Exn.result
val change_state: (state -> state) -> unit
val command_exec: state -> string -> int -> Command.exec option
val consolidate_execution: state -> unit
val define_blob: string -> string -> state -> state
val define_command:
int ->
string ->
blob_digest list ->
int -> ((int * int) * string) list -> state -> state
type edit = string * node_edit
val init_state: state
datatype node_edit
=
Deps of node_header
| Edits of (int option * int option) list
| Perspective of bool * int list * overlay list
type node_header =
{errors: string list, header: Thy_Header.header, master: string}
type overlay = int * (string * string list)
val remove_versions: int list -> state -> state
val start_execution: state -> state
val state: unit -> state
type state
val timing: bool ref
val update:
int ->
int ->
edit list -> state -> int list * (int * int list) list * state
end
structure Document: DOCUMENT
val it = (): unit
signature ISAR_CMD =
sig
val declaration:
{pervasive: bool, syntax: bool} ->
Input.source -> local_theory -> local_theory
val default_proof: Toplevel.transition -> Toplevel.transition
val diag_goal:
Proof.context -> {context: Proof.context, facts: thm list, goal: thm}
val diag_state: Proof.context -> Toplevel.state
val done_proof: Toplevel.transition -> Toplevel.transition
val immediate_proof: Toplevel.transition -> Toplevel.transition
val local_setup: Input.source -> Proof.context -> Proof.context
val ml_diag:
bool -> Input.source -> Toplevel.transition -> Toplevel.transition
val no_translations:
(xstring * string) Syntax.trrule list -> theory -> theory
val oracle: bstring * Position.range -> Input.source -> theory -> theory
val parse_ast_translation: Input.source -> theory -> theory
val parse_translation: Input.source -> theory -> theory
val pretty_theorems: bool -> Toplevel.state -> Pretty.T list
val print_ast_translation: Input.source -> theory -> theory
val print_prfs:
bool ->
string list * (Facts.ref * Token.src list) list option ->
Toplevel.transition -> Toplevel.transition
val print_prop:
string list * string -> Toplevel.transition -> Toplevel.transition
val print_stmts:
string list * (Facts.ref * Token.src list) list ->
Toplevel.transition -> Toplevel.transition
val print_term:
string list * string -> Toplevel.transition -> Toplevel.transition
val print_thms:
string list * (Facts.ref * Token.src list) list ->
Toplevel.transition -> Toplevel.transition
val print_translation: Input.source -> theory -> theory
val print_type:
string list * (string * string option) ->
Toplevel.transition -> Toplevel.transition
val qed:
Method.text_range option ->
Toplevel.transition -> Toplevel.transition
val setup: Input.source -> theory -> theory
val simproc_setup:
string * Position.T ->
string list -> Input.source -> local_theory -> local_theory
val skip_proof: Toplevel.transition -> Toplevel.transition
val terminal_proof:
Method.text_range * Method.text_range option ->
Toplevel.transition -> Toplevel.transition
val translations:
(xstring * string) Syntax.trrule list -> theory -> theory
val typed_print_translation: Input.source -> theory -> theory
end
structure Isar_Cmd: ISAR_CMD
val it = (): unit
val it = (): unit
### ML warning (line 20 of "System/command_line.ML"):
### Handler catches all exceptions.
signature COMMAND_LINE =
sig val tool: (unit -> int) -> unit val tool0: (unit -> unit) -> unit end
structure Command_Line: COMMAND_LINE
val it = (): unit
signature SYSTEM_CHANNEL =
sig
type T
val flush: T -> unit
val inputN: T -> int -> string
val input_line: T -> string option
val output: T -> string -> unit
val rendezvous: string -> T
end
structure System_Channel: SYSTEM_CHANNEL
val it = (): unit
signature MESSAGE_CHANNEL =
sig
type T
val make: System_Channel.T -> T
val message: string -> Properties.T -> string list -> message
type message
val send: T -> message -> unit
val shutdown: T -> unit
end
structure Message_Channel: MESSAGE_CHANNEL
val it = (): unit
### ML warning (line 52 of "System/isabelle_process.ML"):
### Handler catches all exceptions.
### ML warning (line 179 of "System/isabelle_process.ML"):
### Handler catches all exceptions.
### ML warning (line 179 of "System/isabelle_process.ML"):
### Handler catches all exceptions.
signature ISABELLE_PROCESS =
sig
val crashes: exn list Synchronized.var
val init_options: unit -> unit
val init_options_interactive: unit -> unit
val init_protocol: string -> unit
val is_active: unit -> bool
val protocol_command: string -> (string list -> unit) -> unit
val reset_tracing: int -> unit
end
structure Isabelle_Process: ISABELLE_PROCESS
val it = (): unit
### ML warning (line 66 of "System/invoke_scala.ML"):
### Handler catches all exceptions.
### ML warning (line 64 of "System/invoke_scala.ML"):
### Matches are not exhaustive.
signature INVOKE_SCALA =
sig
exception Null
val method: string -> string -> string
val promise_method: string -> string -> string future
end
structure Invoke_Scala: INVOKE_SCALA
val it = (): unit
### ML warning (line 16 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 22 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 34 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 49 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 50 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 38 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 62 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 66 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 70 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 86 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 87 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 98 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 75 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 121 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 134 of "PIDE/protocol.ML"):
### Handler catches all exceptions.
### ML warning (line 132 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
### ML warning (line 138 of "PIDE/protocol.ML"):
### Matches are not exhaustive.
structure Protocol: sig end
val it = (): unit
structure Output_Primitives_Virtual: OUTPUT_PRIMITIVES
val it = (): unit
val it = (): unit
structure ML_PP: sig end
val it = (): unit
### ML warning (line 122 of "ML/ml_antiquotations.ML"):
### Pattern is not exhaustive.
### ML warning (line 132 of "ML/ml_antiquotations.ML"):
### Matches are not exhaustive.
### ML warning (line 134 of "ML/ml_antiquotations.ML"):
### Matches are not exhaustive.
### ML warning (line 136 of "ML/ml_antiquotations.ML"):
### Matches are not exhaustive.
### ML warning (line 146 of "ML/ml_antiquotations.ML"):
### Pattern is not exhaustive.
### ML warning (line 170 of "ML/ml_antiquotations.ML"):
### Pattern is not exhaustive.
structure ML_Antiquotations: sig end
val it = (): unit
signature ML_THMS =
sig
val bind_thm: string * thm -> unit
val bind_thms: string * thm list -> unit
val get_stored_thm: unit -> thm
val get_stored_thms: unit -> thm list
val store_thm: string * thm -> unit
val store_thms: string * thm list -> unit
val the_attributes: Proof.context -> int -> Token.src list
val the_thmss: Proof.context -> thm list list
end
structure ML_Thms: ML_THMS
val it = (): unit
### ML warning (line 18 of "ML/ml_file.ML"):
### Pattern is not exhaustive.
signature ML_FILE =
sig
val ML:
bool option ->
(theory -> Token.file list) ->
Toplevel.transition -> Toplevel.transition
val SML:
bool option ->
(theory -> Token.file list) ->
Toplevel.transition -> Toplevel.transition
end
structure ML_File: ML_FILE
val it = (): unit
### ML warning (line 75 of "Tools/build.ML"):
### Value identifier (output) has not been referenced.
### ML warning (line 228 of "Tools/build.ML"):
### Handler catches all exceptions.
### ML warning (line 239 of "Tools/build.ML"):
### Handler catches all exceptions.
### ML warning (line 238 of "Tools/build.ML"):
### Handler catches all exceptions.
signature BUILD = sig val build: string -> unit end
structure Build: BUILD
val it = (): unit
signature NAMED_THMS =
sig
val add: attribute
val add_thm: thm -> Context.generic -> Context.generic
val del: attribute
val del_thm: thm -> Context.generic -> Context.generic
val get: Proof.context -> thm list
val member: Proof.context -> thm -> bool
val setup: theory -> theory
end
functor Named_Thms (sig val description: string val name: binding end):
NAMED_THMS
val it = (): unit
### ML warning (line 34 of "Tools/print_operation.ML"):
### Matches are not exhaustive.
signature PRINT_OPERATION =
sig
val register:
string -> string -> (Toplevel.state -> Pretty.T list) -> unit
end
structure Print_Operation: PRINT_OPERATION
val it = (): unit
signature BIBTEX = sig val cite_macro: string Config.T end
structure Bibtex: BIBTEX
val it = (): unit
### ML warning (line 326 of "Tools/rail.ML"):
### Pattern is not exhaustive.
### ML warning (line 366 of "Tools/rail.ML"):
### Matches are not exhaustive.
signature RAIL =
sig
val output_rules:
Toplevel.state -> (string Antiquote.antiquote * rail) list -> string
datatype rail
=
Antiquote of bool * Antiquote.antiq
| Bar of rails list
| Newline of int
| Nonterminal of string
| Plus of rails * rails
| Terminal of bool * string
datatype rails = Cat of int * rail list
val read:
Proof.context ->
Input.source -> (string Antiquote.antiquote * rail) list
end
structure Rail: RAIL
val it = (): unit
signature RULE_INSTS =
sig
val cut_inst_tac:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic
val dres_inst_tac:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic
val eres_inst_tac:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic
val forw_inst_tac:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic
val goal_context:
term -> Proof.context -> (string * typ) list * Proof.context
val make_elim_preserve: Proof.context -> thm -> thm
val method:
(Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic)
->
(Proof.context -> thm list -> int -> tactic) ->
(Proof.context -> Proof.method) context_parser
val of_rule:
Proof.context ->
string option list * string option list ->
(binding * string option * mixfix) list -> thm -> thm
val read_instantiate:
Proof.context ->
((indexname * Position.T) * string) list ->
string list -> thm -> thm
val read_term: string -> Proof.context -> term * Proof.context
val res_inst_tac:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> int -> tactic
val subgoal_tac:
Proof.context ->
string -> (binding * string option * mixfix) list -> int -> tactic
val thin_tac:
Proof.context ->
string -> (binding * string option * mixfix) list -> int -> tactic
val where_rule:
Proof.context ->
((indexname * Position.T) * string) list ->
(binding * string option * mixfix) list -> thm -> thm
end
structure Rule_Insts: RULE_INSTS
val it = (): unit
signature THM_DEPS =
sig
val thm_deps: theory -> thm list -> unit
val unused_thms: theory list * theory list -> (string * thm) list
end
structure Thm_Deps: THM_DEPS
val it = (): unit
signature THY_DEPS =
sig
val thy_deps:
Proof.context ->
theory list option * theory list option -> Graph_Display.entry list
val thy_deps_cmd:
Proof.context ->
(string * Position.T) list option *
(string * Position.T) list option
-> unit
end
structure Thy_Deps: THY_DEPS
val it = (): unit
signature CLASS_DEPS =
sig
val class_deps:
Proof.context ->
sort list option * sort list option -> Graph_Display.entry list
val class_deps_cmd:
Proof.context -> string list option * string list option -> unit
end
structure Class_Deps: CLASS_DEPS
val it = (): unit
### ML warning (line 553 of "Tools/find_theorems.ML"):
### Pattern is not exhaustive.
signature FIND_THEOREMS =
sig
datatype 'a criterion
=
Dest
| Elim
| Intro
| Name of string
| Pattern of 'a
| Simp of 'a
| Solves
val find_theorems:
Proof.context ->
thm option ->
int option ->
bool ->
(bool * term criterion) list ->
int option * (Facts.ref * thm) list
val find_theorems_cmd:
Proof.context ->
thm option ->
int option ->
bool ->
(bool * string criterion) list ->
int option * (Facts.ref * thm) list
val pretty_theorems:
Proof.state ->
int option -> bool -> (bool * string criterion) list -> Pretty.T
val pretty_thm: Proof.context -> Facts.ref * thm -> Pretty.T
val proof_state: Toplevel.state -> Proof.state
type 'a query =
{criteria: (bool * 'a criterion) list,
goal: thm option, limit: int option, rem_dups: bool}
val query_parser: (bool * string criterion) list parser
val read_query: Position.T -> string -> (bool * string criterion) list
end
structure Find_Theorems: FIND_THEOREMS
val it = (): unit
### ML warning (line 167 of "Tools/find_consts.ML"):
### Pattern is not exhaustive.
signature FIND_CONSTS =
sig
datatype criterion = Loose of string | Name of string | Strict of string
val find_consts: Proof.context -> (bool * criterion) list -> unit
val pretty_consts: Proof.context -> (bool * criterion) list -> Pretty.T
val query_parser: (bool * criterion) list parser
val read_query: Position.T -> string -> (bool * criterion) list
end
structure Find_Consts: FIND_CONSTS
val it = (): unit
### ML warning (line 416 of "Tools/simplifier_trace.ML"):
### Handler catches all exceptions.
### ML warning (line 406 of "Tools/simplifier_trace.ML"):
### Matches are not exhaustive.
signature SIMPLIFIER_TRACE =
sig
val add_term_breakpoint: term -> Context.generic -> Context.generic
val add_thm_breakpoint: thm -> Context.generic -> Context.generic
val disable: Proof.context -> Proof.context
end
structure Simplifier_Trace: SIMPLIFIER_TRACE
val it = (): unit
### ML warning (line 33 of "Tools/debugger.ML"):
### Handler catches all exceptions.
### ML warning (line 245 of "Tools/debugger.ML"):
### Matches are not exhaustive.
### ML warning (line 258 of "Tools/debugger.ML"):
### Matches are not exhaustive.
### ML warning (line 262 of "Tools/debugger.ML"):
### Matches are not exhaustive.
### ML warning (line 266 of "Tools/debugger.ML"):
### Matches are not exhaustive.
### ML warning (line 292 of "Tools/debugger.ML"):
### Matches are not exhaustive.
signature DEBUGGER =
sig
val error_message: string -> unit
val warning_message: string -> unit
val writeln_message: string -> unit
end
structure Debugger: DEBUGGER
val it = (): unit
signature NAMED_THEOREMS =
sig
val add: string -> attribute
val add_thm: string -> thm -> Context.generic -> Context.generic
val check: Proof.context -> string * Position.T -> string
val clear: string -> Context.generic -> Context.generic
val declare: binding -> string -> local_theory -> string * local_theory
val del: string -> attribute
val del_thm: string -> thm -> Context.generic -> Context.generic
val get: Proof.context -> string -> thm list
val member: Proof.context -> string -> thm -> bool
end
structure Named_Theorems: NAMED_THEOREMS
val it = (): unit
signature JEDIT = sig val check_action: string * Position.T -> string end
structure JEdit: JEDIT
val it = (): unit
Loading theory "Pure"
### theory "Pure"
### 0.435s elapsed time, 0.435s cpu time, 0.015s GC time
Loading theory "ML_Bootstrap"
structure Output_Primitives: OUTPUT_PRIMITIVES
structure Thread_Data: THREAD_DATA
val ML_system_pp = fn: (int -> 'a -> 'b -> PolyML.pretty) -> unit
val it = (): unit
val it = (): unit
structure PolyML:
sig
structure IntInf:
sig val gcd: int * int -> int val lcm: int * int -> int end
end
val it = (): unit
val it = (): unit
### theory "ML_Bootstrap"
### 0.006s elapsed time, 0.006s cpu time, 0.000s GC time
-------------- next part --------------
manuel at colosson ~/T/I/s/Pure> isabelle build -c Pure
Cleaning Pure ...
Building Pure ...
Pure FAILED
(see also /home/manuel/.isabelle/Isabelle2017/heaps/polyml-5.6_x86-linux/log/Pure)
val warning_message: string -> unit
val writeln_message: string -> unit
end
structure Debugger: DEBUGGER
val it = (): unit
signature NAMED_THEOREMS =
sig
val add: string -> attribute
val add_thm: string -> thm -> Context.generic -> Context.generic
val check: Proof.context -> string * Position.T -> string
val clear: string -> Context.generic -> Context.generic
val declare: binding -> string -> local_theory -> string * local_theory
val del: string -> attribute
val del_thm: string -> thm -> Context.generic -> Context.generic
val get: Proof.context -> string -> thm list
val member: Proof.context -> string -> thm -> bool
end
structure Named_Theorems: NAMED_THEOREMS
val it = (): unit
signature JEDIT = sig val check_action: string * Position.T -> string end
structure JEdit: JEDIT
val it = (): unit
Loading theory "Pure"
### theory "Pure"
### 0.435s elapsed time, 0.435s cpu time, 0.015s GC time
Loading theory "ML_Bootstrap"
structure Output_Primitives: OUTPUT_PRIMITIVES
structure Thread_Data: THREAD_DATA
val ML_system_pp = fn: (int -> 'a -> 'b -> PolyML.pretty) -> unit
val it = (): unit
val it = (): unit
structure PolyML:
sig
structure IntInf:
sig val gcd: int * int -> int val lcm: int * int -> int end
end
val it = (): unit
val it = (): unit
### theory "ML_Bootstrap"
### 0.006s elapsed time, 0.006s cpu time, 0.000s GC time
Unfinished session(s): Pure
0:00:31 elapsed time, 0:00:09 cpu time, factor 0.31
More information about the isabelle-dev
mailing list