lean2/library/init/reserved_notation.lean

/-
Copyright (c) 2014 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.

Module: init.reserved_notation
Authors: Leonardo de Moura, Jeremy Avigad
-/
prelude
import init.datatypes

notation `assume` binders `,` r:(scoped f, f) := r
notation `take`   binders `,` r:(scoped f, f) := r

/-
  Global declarations of right binding strength

  If a module reassigns these, it will be incompatible with other modules that adhere to these
  conventions.

  When hovering over a symbol, use "C-c C-k" to see how to input it.
-/

definition std.prec.max   : num := 1024 -- the strength of application, identifiers, (, [, etc.
definition std.prec.arrow : num := 25

/-
The next definition is "max + 10". It can be used e.g. for postfix operations that should
be stronger than application.
-/

definition std.prec.max_plus :=
num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ
  (num.succ std.prec.max)))))))))

/- Logical operations and relations -/

reserve prefix `¬`:40
reserve prefix `~`:40
reserve infixr `∧`:35
reserve infixr `/\`:35
reserve infixr `\/`:30
reserve infixr `∨`:30
reserve infix `<->`:20
reserve infix `↔`:20
reserve infix `=`:50
reserve infix `≠`:50
reserve infix `≈`:50
reserve infix `∼`:50
reserve infix `≡`:50

reserve infixr `∘`:60                   -- input with \comp
reserve postfix `⁻¹`:std.prec.max_plus  -- input with \sy or \-1 or \inv

reserve infixl `⬝`:75
reserve infixr `▸`:75

/- types and type constructors -/

reserve infixl `⊎`:25
reserve infixl `×`:30

/- arithmetic operations -/

reserve infixl `+`:65
reserve infixl `-`:65
reserve infixl `*`:70
reserve infixl `div`:70
reserve infixl `mod`:70
reserve infixl `/`:70
reserve prefix `-`:100
reserve infix `^`:80

reserve infix `<=`:50
reserve infix `≤`:50
reserve infix `<`:50
reserve infix `>=`:50
reserve infix `≥`:50
reserve infix `>`:50

/- boolean operations -/

reserve infixl `&&`:70
reserve infixl `||`:65

/- set operations -/

reserve infix `∈`:50
reserve infix `∉`:50
reserve infixl `∩`:70
reserve infixl `∪`:65

/- other symbols -/

reserve infix `∣`:50
reserve infixl `++`:65
reserve infixr `::`:65

-- Yet another trick to anotate an expression with a type
abbreviation is_typeof (A : Type) (a : A) : A := a

notation `typeof` t `:` T  := is_typeof T t
notation `(` t `:` T `)`  := is_typeof T t
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/-
 								Copyright (c) 2014 Microsoft Corporation. All rights reserved.
 								Released under Apache 2.0 license as described in the file LICENSE.
-												refactor(library/standard): integrate hott with standard library

											
										
										
											2014-08-12 00:35:25 +00:00
-												style(hott): let inverse notation have higher binding power than application

											
										
										
											2015-02-28 00:02:18 +00:00
+								Module: init.reserved_notation
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								Authors: Leonardo de Moura, Jeremy Avigad
 								-/
-												refactor(library): add 'init' folder

											
										
										
											2014-12-01 04:34:12 +00:00
+								prelude
 								import init.datatypes
-												refactor(library/standard): integrate hott with standard library

											
										
										
											2014-08-12 00:35:25 +00:00
 								notation `assume` binders `,` r:(scoped f, f) := r
 								notation `take`   binders `,` r:(scoped f, f) := r
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/-
 								  Global declarations of right binding strength
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								  If a module reassigns these, it will be incompatible with other modules that adhere to these
 								  conventions.
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												fix(reserved_notation): lower binding power of 'iff'

											
										
										
											2015-04-22 19:13:34 +00:00
+								  When hovering over a symbol, use "C-c C-k" to see how to input it.
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								-/
-												refactor(library/init/reserved_notation): increase binding strength of ^-1 to max+10

											
										
										
											2015-01-26 16:28:13 +00:00
+								definition std.prec.max   : num := 1024 -- the strength of application, identifiers, (, [, etc.
-												feat(frontends/lean): allow expressions to be used to define precedence, closes #335

											
										
										
											2014-11-30 02:29:48 +00:00
+								definition std.prec.arrow : num := 25
-												refactor(library/init/reserved_notation): increase binding strength of ^-1 to max+10

											
										
										
											2015-01-26 16:28:13 +00:00
+								/-
 								The next definition is "max + 10". It can be used e.g. for postfix operations that should
 								be stronger than application.
 								-/
 								definition std.prec.max_plus :=
 								num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ (num.succ
 								  (num.succ std.prec.max)))))))))
 								/- Logical operations and relations -/
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve prefix `¬`:40
-												style(library): add some comments

											
										
										
											2014-11-09 01:54:17 +00:00
+								reserve prefix `~`:40
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixr `∧`:35
 								reserve infixr `/\`:35
-												fix(init/reserved_notation): remove "invisible" character at `\/`

											
										
										
											2014-12-02 20:06:39 +00:00
+								reserve infixr `\/`:30
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixr `∨`:30
-												fix(reserved_notation): lower binding power of 'iff'

											
										
										
											2015-04-22 19:13:34 +00:00
+								reserve infix `<->`:20
 								reserve infix `↔`:20
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infix `=`:50
 								reserve infix `≠`:50
 								reserve infix `≈`:50
 								reserve infix `∼`:50
-												feat(library/init/reserved_notation.lean): add equiv relation symbol

											
										
										
											2015-04-18 17:41:58 +00:00
+								reserve infix `≡`:50
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
-												refactor(library/init/reserved_notation): increase binding strength of ^-1 to max+10

											
										
										
											2015-01-26 16:28:13 +00:00
+								reserve infixr `∘`:60                   -- input with \comp
 								reserve postfix `⁻¹`:std.prec.max_plus  -- input with \sy or \-1 or \inv
-												fix(library/general_notation): mark \tr as left associative

											
										
										
											2014-10-23 05:12:53 +00:00
+								reserve infixl `⬝`:75
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixr `▸`:75
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/- types and type constructors -/
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixl `⊎`:25
 								reserve infixl `×`:30
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/- arithmetic operations -/
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixl `+`:65
 								reserve infixl `-`:65
 								reserve infixl `*`:70
 								reserve infixl `div`:70
 								reserve infixl `mod`:70
-												feat(frontends/lean): parse rewrite tactic

											
										
										
											2015-02-03 01:02:14 +00:00
+								reserve infixl `/`:70
-												feat(library/general_notation): reserve unary minus

											
										
										
											2014-11-14 06:08:20 +00:00
+								reserve prefix `-`:100
-												feat(library/algebra/group_pow.lean,library/data/nat/power.lean): add generic power operation on monoids and groups

											
										
										
											2015-05-14 04:48:32 +00:00
+								reserve infix `^`:80
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infix `<=`:50
 								reserve infix `≤`:50
 								reserve infix `<`:50
 								reserve infix `>=`:50
 								reserve infix `≥`:50
 								reserve infix `>`:50
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/- boolean operations -/
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixl `&&`:70
 								reserve infixl `||`:65
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/- set operations -/
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infix `∈`:50
-												feat(init): reserve notation for "not in"

											
										
										
											2014-12-15 02:49:19 +00:00
+								reserve infix `∉`:50
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixl `∩`:70
 								reserve infixl `∪`:65
-												refactor(library/standard): collect notation in general_notation

											
										
										
											2014-08-22 23:36:47 +00:00
-												feat(library): reorganize and declare some notation

											
										
										
											2014-11-28 12:06:46 +00:00
+								/- other symbols -/
-												feat(frontends/lean): round parenthesis for [tactic1 | tactic2]

This commit also replaces the notation for divides
     `(` a `|` b `)`
with
      a `∣` b

The character `∣` is entered by typing \|

closes #516

											
										
										
											2015-04-06 16:24:09 +00:00
+								reserve infix `∣`:50
-												refactor(library): use 'reserve' notation in the standard library

											
										
										
											2014-10-21 21:08:07 +00:00
+								reserve infixl `++`:65
 								reserve infixr `::`:65
-												refactor(typeof): move typeof to general_notation

											
										
										
											2014-11-06 23:54:18 +00:00
 								-- Yet another trick to anotate an expression with a type
-												fix(reserved_notation): make is_typeof an abbreviation

											
										
										
											2015-04-10 01:41:23 +00:00
+								abbreviation is_typeof (A : Type) (a : A) : A := a
-												refactor(typeof): move typeof to general_notation

											
										
										
											2014-11-06 23:54:18 +00:00
 								notation `typeof` t `:` T  := is_typeof T t
-												feat(library,hott): new notation for typeof

											
										
										
											2015-03-25 01:35:21 +00:00
+								notation `(` t `:` T `)`  := is_typeof T t