Loogle!
Result
Found 1820 declarations whose name contains "Batteries". Of these, only the first 200 are shown.
- Batteries.Util.LibraryNote.LibraryNoteEntry 📋 Batteries.Util.LibraryNote
: Type - Batteries.Util.LibraryNote.commandLibrary_note___ 📋 Batteries.Util.LibraryNote
: Lean.ParserDescr - Batteries.Util.LibraryNote.instLibraryNoteEntryInhabited 📋 Batteries.Util.LibraryNote
: Inhabited Batteries.Util.LibraryNote.LibraryNoteEntry - Batteries.Util.LibraryNote.libraryNoteExt 📋 Batteries.Util.LibraryNote
: Lean.SimplePersistentEnvExtension Batteries.Util.LibraryNote.LibraryNoteEntry (Array Batteries.Util.LibraryNote.LibraryNoteEntry) - Batteries.Tactic.seq_focus 📋 Batteries.Tactic.SeqFocus
: Lean.TrailingParserDescr - Batteries.Tactic.«tacticMap_tacs[_;]» 📋 Batteries.Tactic.SeqFocus
: Lean.ParserDescr - Batteries.OrientedOrd 📋 Batteries.Classes.Order
(α : Type u_1) [Ord α] : Prop - Batteries.TransOrd 📋 Batteries.Classes.Order
(α : Type u_1) [Ord α] : Prop - Batteries.OrientedCmp 📋 Batteries.Classes.Order
{α : Sort u_1} (cmp : α → α → Ordering) : Prop - Batteries.TotalBLE 📋 Batteries.Classes.Order
{α : Sort u_1} (le : α → α → Bool) : Prop - Batteries.TransCmp 📋 Batteries.Classes.Order
{α : Sort u_1} (cmp : α → α → Ordering) : Prop - Batteries.BEqOrd 📋 Batteries.Classes.Order
(α : Type u_1) [BEq α] [Ord α] : Prop - Batteries.LEOrd 📋 Batteries.Classes.Order
(α : Type u_1) [LE α] [Ord α] : Prop - Batteries.LTOrd 📋 Batteries.Classes.Order
(α : Type u_1) [LT α] [Ord α] : Prop - Batteries.BEqCmp 📋 Batteries.Classes.Order
{α : Type u_1} [BEq α] (cmp : α → α → Ordering) : Prop - Batteries.LECmp 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] (cmp : α → α → Ordering) : Prop - Batteries.LTCmp 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] (cmp : α → α → Ordering) : Prop - Batteries.instLawfulOrdBool 📋 Batteries.Classes.Order
: Batteries.LawfulOrd Bool - Batteries.instLawfulOrdInt 📋 Batteries.Classes.Order
: Batteries.LawfulOrd ℤ - Batteries.instLawfulOrdNat 📋 Batteries.Classes.Order
: Batteries.LawfulOrd ℕ - Batteries.LawfulOrd 📋 Batteries.Classes.Order
(α : Type u_1) [LE α] [LT α] [BEq α] [Ord α] : Prop - Batteries.TransCmp.toOrientedCmp 📋 Batteries.Classes.Order
{α : Sort u_1} {cmp : α → α → Ordering} [self : Batteries.TransCmp cmp] : Batteries.OrientedCmp cmp - Batteries.LawfulCmp 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] [LT α] [BEq α] (cmp : α → α → Ordering) : Prop - Batteries.OrientedOrd.instOpposite 📋 Batteries.Classes.Order
{α : Type u_1} [ord : Ord α] [inst : Batteries.OrientedOrd α] : Batteries.OrientedOrd α - Batteries.TransOrd.instOpposite 📋 Batteries.Classes.Order
{α : Type u_1} [ord : Ord α] [inst : Batteries.TransOrd α] : Batteries.TransOrd α - Batteries.LECmp.toOrientedCmp 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {cmp : α → α → Ordering} [self : Batteries.LECmp cmp] : Batteries.OrientedCmp cmp - Batteries.LTCmp.toOrientedCmp 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LT α} {cmp : α → α → Ordering} [self : Batteries.LTCmp cmp] : Batteries.OrientedCmp cmp - Batteries.OrientedOrd.eq_1 📋 Batteries.Classes.Order
(α : Type u_1) [Ord α] : Batteries.OrientedOrd α = Batteries.OrientedCmp compare - Batteries.TransOrd.eq_1 📋 Batteries.Classes.Order
(α : Type u_1) [Ord α] : Batteries.TransOrd α = Batteries.TransCmp compare - Batteries.instOrientedCmpFlipOrdering 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [inst : Batteries.OrientedCmp cmp] : Batteries.OrientedCmp (flip cmp) - Batteries.instTransCmpFlipOrdering 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [inst : Batteries.TransCmp cmp] : Batteries.TransCmp (flip cmp) - Batteries.OrientedCmp.cmp_refl 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x : α✝} [Batteries.OrientedCmp cmp] : cmp x x = Ordering.eq - Batteries.instLawfulOrdFin 📋 Batteries.Classes.Order
{n : ℕ} : Batteries.LawfulOrd (Fin n) - Batteries.instOrientedCmpCompareOnOfOrientedOrd 📋 Batteries.Classes.Order
{β : Type u_1} {α : Sort u_2} [Ord β] [Batteries.OrientedOrd β] (f : α → β) : Batteries.OrientedCmp (compareOn f) - Batteries.instTransCmpCompareOnOfTransOrd 📋 Batteries.Classes.Order
{β : Type u_1} {α : Sort u_2} [Ord β] [Batteries.TransOrd β] (f : α → β) : Batteries.TransCmp (compareOn f) - Batteries.OrientedOrd.instOn 📋 Batteries.Classes.Order
{β : Type u_1} {α : Type u_2} [ord : Ord β] [Batteries.OrientedOrd β] (f : α → β) : Batteries.OrientedOrd α - Batteries.TransOrd.instOn 📋 Batteries.Classes.Order
{β : Type u_1} {α : Type u_2} [ord : Ord β] [Batteries.TransOrd β] (f : α → β) : Batteries.TransOrd α - Batteries.OrientedOrd.instOrdLex' 📋 Batteries.Classes.Order
{α : Type u_1} (ord₁ ord₂ : Ord α) [Batteries.OrientedOrd α] [Batteries.OrientedOrd α] : Batteries.OrientedOrd α - Batteries.TransOrd.instOrdLex' 📋 Batteries.Classes.Order
{α : Type u_1} (ord₁ ord₂ : Ord α) [Batteries.TransOrd α] [Batteries.TransOrd α] : Batteries.TransOrd α - Batteries.OrientedCmp.mk 📋 Batteries.Classes.Order
{α : Sort u_1} {cmp : α → α → Ordering} (symm : ∀ (x y : α), (cmp x y).swap = cmp y x) : Batteries.OrientedCmp cmp - Batteries.OrientedCmp.symm 📋 Batteries.Classes.Order
{α : Sort u_1} {cmp : α → α → Ordering} [self : Batteries.OrientedCmp cmp] (x y : α) : (cmp x y).swap = cmp y x - Batteries.LawfulCmp.toTransCmp 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {inst✝¹ : LT α} {inst✝² : BEq α} {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] : Batteries.TransCmp cmp - Batteries.instOrientedCmpCompareLex 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp₁ cmp₂ : α✝ → α✝ → Ordering} [inst₁ : Batteries.OrientedCmp cmp₁] [inst₂ : Batteries.OrientedCmp cmp₂] : Batteries.OrientedCmp (compareLex cmp₁ cmp₂) - Batteries.instTransCmpCompareLex 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp₁ cmp₂ : α✝ → α✝ → Ordering} [inst₁ : Batteries.TransCmp cmp₁] [inst₂ : Batteries.TransCmp cmp₂] : Batteries.TransCmp (compareLex cmp₁ cmp₂) - Batteries.LawfulCmp.toBEqCmp 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {inst✝¹ : LT α} {inst✝² : BEq α} {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] : Batteries.BEqCmp cmp - Batteries.LawfulCmp.toLECmp 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] [LT α] [BEq α] {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] : Batteries.LECmp cmp - Batteries.LawfulCmp.toLTCmp 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] [LT α] [BEq α] {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] : Batteries.LTCmp cmp - Batteries.OrientedCmp.gt_asymm 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x y : α✝} [Batteries.OrientedCmp cmp] (h : cmp x y = Ordering.gt) : cmp y x ≠ Ordering.gt - Batteries.OrientedCmp.lt_asymm 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x y : α✝} [Batteries.OrientedCmp cmp] (h : cmp x y = Ordering.lt) : cmp y x ≠ Ordering.lt - Batteries.OrientedOrd.instLexOrd 📋 Batteries.Classes.Order
{α : Type u_1} {β : Type u_2} [Ord α] [Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β] : Batteries.OrientedOrd (α × β) - Batteries.OrientedOrd.instOrdLex 📋 Batteries.Classes.Order
{α : Type u_1} {β : Type u_2} [oα : Ord α] [oβ : Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β] : Batteries.OrientedOrd (α × β) - Batteries.TransOrd.instLexOrd 📋 Batteries.Classes.Order
{α : Type u_1} {β : Type u_2} [Ord α] [Ord β] [Batteries.TransOrd α] [Batteries.TransOrd β] : Batteries.TransOrd (α × β) - Batteries.TransOrd.instOrdLex 📋 Batteries.Classes.Order
{α : Type u_1} {β : Type u_2} [oα : Ord α] [oβ : Ord β] [Batteries.TransOrd α] [Batteries.TransOrd β] : Batteries.TransOrd (α × β) - Batteries.OrientedCmp.cmp_eq_eq_symm 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x y : α✝} [Batteries.OrientedCmp cmp] : cmp x y = Ordering.eq ↔ cmp y x = Ordering.eq - Batteries.OrientedCmp.cmp_eq_gt 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x y : α✝} [Batteries.OrientedCmp cmp] : cmp x y = Ordering.gt ↔ cmp y x = Ordering.lt - Batteries.OrientedCmp.cmp_ne_gt 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} {x y : α✝} [Batteries.OrientedCmp cmp] : cmp x y ≠ Ordering.gt ↔ cmp y x ≠ Ordering.lt - Batteries.TotalBLE.mk 📋 Batteries.Classes.Order
{α : Sort u_1} {le : α → α → Bool} (total : ∀ {a b : α}, le a b = true ∨ le b a = true) : Batteries.TotalBLE le - Batteries.TotalBLE.total 📋 Batteries.Classes.Order
{α : Sort u_1} {le : α → α → Bool} [self : Batteries.TotalBLE le] {a b : α} : le a b = true ∨ le b a = true - Batteries.TransCmp.cmp_congr_left' 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y : α✝} (xy : cmp x y = Ordering.eq) : cmp x = cmp y - Batteries.LECmp.cmp_iff_ge 📋 Batteries.Classes.Order
{α : Type u_1} {cmp : α → α → Ordering} {x y : α} [LE α] [Batteries.LECmp cmp] : cmp x y ≠ Ordering.lt ↔ y ≤ x - Batteries.LECmp.cmp_iff_le 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {cmp : α → α → Ordering} [self : Batteries.LECmp cmp] {x y : α} : cmp x y ≠ Ordering.gt ↔ x ≤ y - Batteries.LTCmp.cmp_iff_gt 📋 Batteries.Classes.Order
{α : Type u_1} {cmp : α → α → Ordering} {x y : α} [LT α] [Batteries.LTCmp cmp] : cmp x y = Ordering.gt ↔ y < x - Batteries.LTCmp.cmp_iff_lt 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LT α} {cmp : α → α → Ordering} [self : Batteries.LTCmp cmp] {x y : α} : cmp x y = Ordering.lt ↔ x < y - Batteries.TransCmp.cmp_congr_left 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (xy : cmp x y = Ordering.eq) : cmp x z = cmp y z - Batteries.TransCmp.cmp_congr_right 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {y z x : α✝} (yz : cmp y z = Ordering.eq) : cmp x y = cmp x z - Batteries.BEqCmp.cmp_iff_eq 📋 Batteries.Classes.Order
{α : Type u_1} {cmp : α → α → Ordering} {x y : α} [BEq α] [LawfulBEq α] [Batteries.BEqCmp cmp] : cmp x y = Ordering.eq ↔ x = y - Batteries.BEqCmp.cmp_iff_beq 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : BEq α} {cmp : α → α → Ordering} [self : Batteries.BEqCmp cmp] {x y : α} : cmp x y = Ordering.eq ↔ (x == y) = true - Batteries.BEqCmp.mk 📋 Batteries.Classes.Order
{α : Type u_1} [BEq α] {cmp : α → α → Ordering} (cmp_iff_beq : ∀ {x y : α}, cmp x y = Ordering.eq ↔ (x == y) = true) : Batteries.BEqCmp cmp - Batteries.LECmp.mk 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] {cmp : α → α → Ordering} [toOrientedCmp : Batteries.OrientedCmp cmp] (cmp_iff_le : ∀ {x y : α}, cmp x y ≠ Ordering.gt ↔ x ≤ y) : Batteries.LECmp cmp - Batteries.LTCmp.mk 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] {cmp : α → α → Ordering} [toOrientedCmp : Batteries.OrientedCmp cmp] (cmp_iff_lt : ∀ {x y : α}, cmp x y = Ordering.lt ↔ x < y) : Batteries.LTCmp cmp - Batteries.TransCmp.ge_trans 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (h₁ : cmp x y ≠ Ordering.lt) (h₂ : cmp y z ≠ Ordering.lt) : cmp x z ≠ Ordering.lt - Batteries.TransCmp.gt_trans 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (h₁ : cmp x y = Ordering.gt) (h₂ : cmp y z = Ordering.gt) : cmp x z = Ordering.gt - Batteries.TransCmp.le_lt_trans 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (h₁ : cmp x y ≠ Ordering.gt) (h₂ : cmp y z = Ordering.lt) : cmp x z = Ordering.lt - Batteries.TransCmp.le_trans 📋 Batteries.Classes.Order
{α : Sort u_1} {cmp : α → α → Ordering} [self : Batteries.TransCmp cmp] {x y z : α} : cmp x y ≠ Ordering.gt → cmp y z ≠ Ordering.gt → cmp x z ≠ Ordering.gt - Batteries.TransCmp.lt_le_trans 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (h₁ : cmp x y = Ordering.lt) (h₂ : cmp y z ≠ Ordering.gt) : cmp x z = Ordering.lt - Batteries.TransCmp.lt_trans 📋 Batteries.Classes.Order
{α✝ : Sort u_1} {cmp : α✝ → α✝ → Ordering} [Batteries.TransCmp cmp] {x y z : α✝} (h₁ : cmp x y = Ordering.lt) (h₂ : cmp y z = Ordering.lt) : cmp x z = Ordering.lt - Batteries.compareOfLessAndEq_eq_lt 📋 Batteries.Classes.Order
{α : Type u_1} {x y : α} [LT α] [Decidable (x < y)] [DecidableEq α] : compareOfLessAndEq x y = Ordering.lt ↔ x < y - Batteries.LawfulCmp.cmp_iff_le 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {inst✝¹ : LT α} {inst✝² : BEq α} {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] {x y : α} : cmp x y ≠ Ordering.gt ↔ x ≤ y - Batteries.LawfulCmp.cmp_iff_lt 📋 Batteries.Classes.Order
{α : Type u_1} {inst✝ : LE α} {inst✝¹ : LT α} {inst✝² : BEq α} {cmp : α → α → Ordering} [self : Batteries.LawfulCmp cmp] {x y : α} : cmp x y = Ordering.lt ↔ x < y - Batteries.TransCmp.mk 📋 Batteries.Classes.Order
{α : Sort u_1} {cmp : α → α → Ordering} [toOrientedCmp : Batteries.OrientedCmp cmp] (le_trans : ∀ {x y z : α}, cmp x y ≠ Ordering.gt → cmp y z ≠ Ordering.gt → cmp x z ≠ Ordering.gt) : Batteries.TransCmp cmp - Batteries.BEqCmp.compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [BEq α] [LawfulBEq α] (lt_irrefl : ∀ (x : α), ¬x < x) : Batteries.BEqCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.LTCmp.eq_compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} {cmp : α → α → Ordering} [LT α] [DecidableEq α] [BEq α] [LawfulBEq α] [Batteries.BEqCmp cmp] [Batteries.LTCmp cmp] (x y : α) [Decidable (x < y)] : cmp x y = compareOfLessAndEq x y - Batteries.LawfulCmp.mk 📋 Batteries.Classes.Order
{α : Type u_1} [LE α] [LT α] [BEq α] {cmp : α → α → Ordering} [toTransCmp : Batteries.TransCmp cmp] [toBEqCmp : Batteries.BEqCmp cmp] (cmp_iff_lt : ∀ {x y : α}, cmp x y = Ordering.lt ↔ x < y) (cmp_iff_le : ∀ {x y : α}, cmp x y ≠ Ordering.gt ↔ x ≤ y) : Batteries.LawfulCmp cmp - Batteries.TransCmp.compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) : Batteries.TransCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.LTCmp.compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (lt_antisymm : ∀ {x y : α}, ¬x < y → ¬y < x → x = y) : Batteries.LTCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.TransCmp.compareOfLessAndEq_of_le 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [LE α] [DecidableRel LT.lt] [DecidableEq α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) : Batteries.TransCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.LTCmp.compareOfLessAndEq_of_le 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y → y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) : Batteries.LTCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.LECmp.compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) : Batteries.LECmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.LawfulCmp.compareOfLessAndEq 📋 Batteries.Classes.Order
{α : Type u_1} [LT α] [DecidableRel LT.lt] [DecidableEq α] [BEq α] [LawfulBEq α] [LE α] (lt_irrefl : ∀ (x : α), ¬x < x) (lt_trans : ∀ {x y z : α}, x < y → y < z → x < z) (not_lt : ∀ {x y : α}, ¬x < y ↔ y ≤ x) (le_antisymm : ∀ {x y : α}, x ≤ y → y ≤ x → x = y) : Batteries.LawfulCmp fun x1 x2 => compareOfLessAndEq x1 x2 - Batteries.Tactic.Lint.Linter 📋 Batteries.Tactic.Lint.Basic
: Type - Batteries.Tactic.Lint.NamedLinter 📋 Batteries.Tactic.Lint.Basic
: Type - Batteries.Tactic.Lint.env_linter 📋 Batteries.Tactic.Lint.Basic
: Lean.ParserDescr - Batteries.Tactic.Lint.nolint 📋 Batteries.Tactic.Lint.Basic
: Lean.ParserDescr - Batteries.Tactic.Lint.Linter.errorsFound 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.Linter) : Lean.MessageData - Batteries.Tactic.Lint.Linter.isFast 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.Linter) : Bool - Batteries.Tactic.Lint.Linter.noErrorsFound 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.Linter) : Lean.MessageData - Batteries.Tactic.Lint.NamedLinter.declName 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.NamedLinter) : Lean.Name - Batteries.Tactic.Lint.NamedLinter.name 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.NamedLinter) : Lean.Name - Batteries.Tactic.Lint.NamedLinter.toLinter 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.NamedLinter) : Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.isAutoDecl 📋 Batteries.Tactic.Lint.Basic
(decl : Lean.Name) : Lean.CoreM Bool - Batteries.Tactic.Lint.nolintAttr 📋 Batteries.Tactic.Lint.Basic
: Lean.ParametricAttribute (Array Lean.Name) - Batteries.Tactic.Lint.getLinter 📋 Batteries.Tactic.Lint.Basic
(name declName : Lean.Name) : Lean.CoreM Batteries.Tactic.Lint.NamedLinter - Batteries.Tactic.Lint.NamedLinter.mk 📋 Batteries.Tactic.Lint.Basic
(toLinter : Batteries.Tactic.Lint.Linter) (name declName : Lean.Name) : Batteries.Tactic.Lint.NamedLinter - Batteries.Tactic.Lint.getLinter.unsafe_1 📋 Batteries.Tactic.Lint.Basic
(name declName : Lean.Name) : Lean.CoreM Batteries.Tactic.Lint.NamedLinter - Batteries.Tactic.Lint.getLinter.unsafe_impl_1 📋 Batteries.Tactic.Lint.Basic
(name declName : Lean.Name) : Lean.CoreM Batteries.Tactic.Lint.NamedLinter - Batteries.Tactic.Lint.Linter.test 📋 Batteries.Tactic.Lint.Basic
(self : Batteries.Tactic.Lint.Linter) : Lean.Name → Lean.MetaM (Option Lean.MessageData) - Batteries.Tactic.Lint.Linter.mk 📋 Batteries.Tactic.Lint.Basic
(test : Lean.Name → Lean.MetaM (Option Lean.MessageData)) (noErrorsFound errorsFound : Lean.MessageData) (isFast : Bool) : Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.shouldBeLinted 📋 Batteries.Tactic.Lint.Basic
{m : Type → Type} [Monad m] [Lean.MonadEnv m] (linter decl : Lean.Name) : m Bool - Batteries.Tactic.Lint.batteriesLinterExt 📋 Batteries.Tactic.Lint.Basic
: Lean.PersistentEnvExtension (Lean.Name × Bool) (Lean.Name × Bool) (Lean.NameMap (Lean.Name × Bool)) - Batteries.Tactic.Lint.NamedLinter.mk.injEq 📋 Batteries.Tactic.Lint.Basic
(toLinter : Batteries.Tactic.Lint.Linter) (name declName : Lean.Name) (toLinter✝ : Batteries.Tactic.Lint.Linter) (name✝ declName✝ : Lean.Name) : ({ toLinter := toLinter, name := name, declName := declName } = { toLinter := toLinter✝, name := name✝, declName := declName✝ }) = (toLinter = toLinter✝ ∧ name = name✝ ∧ declName = declName✝) - Batteries.Tactic.Lint.Linter.mk.injEq 📋 Batteries.Tactic.Lint.Basic
(test : Lean.Name → Lean.MetaM (Option Lean.MessageData)) (noErrorsFound errorsFound : Lean.MessageData) (isFast : Bool) (test✝ : Lean.Name → Lean.MetaM (Option Lean.MessageData)) (noErrorsFound✝ errorsFound✝ : Lean.MessageData) (isFast✝ : Bool) : ({ test := test, noErrorsFound := noErrorsFound, errorsFound := errorsFound, isFast := isFast } = { test := test✝, noErrorsFound := noErrorsFound✝, errorsFound := errorsFound✝, isFast := isFast✝ }) = (test = test✝ ∧ noErrorsFound = noErrorsFound✝ ∧ errorsFound = errorsFound✝ ∧ isFast = isFast✝) - Batteries.Tactic.Lint.NamedLinter.mk.sizeOf_spec 📋 Batteries.Tactic.Lint.Basic
(toLinter : Batteries.Tactic.Lint.Linter) (name declName : Lean.Name) : sizeOf { toLinter := toLinter, name := name, declName := declName } = 1 + sizeOf toLinter + sizeOf name + sizeOf declName - Batteries.Tactic.Lint.Linter.mk.sizeOf_spec 📋 Batteries.Tactic.Lint.Basic
(test : Lean.Name → Lean.MetaM (Option Lean.MessageData)) (noErrorsFound errorsFound : Lean.MessageData) (isFast : Bool) : sizeOf { test := test, noErrorsFound := noErrorsFound, errorsFound := errorsFound, isFast := isFast } = 1 + sizeOf noErrorsFound + sizeOf errorsFound + sizeOf isFast - Batteries.Tactic.Lint.checkType 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.checkUnivs 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.defLemma 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.docBlame 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.docBlameThm 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.dupNamespace 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.explicitVarsOfIff 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.synTaut 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.unusedArguments 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.unusedHavesSuffices 📋 Batteries.Tactic.Lint.Misc
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.findUnusedHaves 📋 Batteries.Tactic.Lint.Misc
(e : Lean.Expr) : Lean.MetaM (Array Lean.MessageData) - Lean.instDecidableEqModuleIdx_batteries 📋 Batteries.Tactic.OpenPrivate
: DecidableEq Lean.ModuleIdx - Batteries.Tactic.Lint.SimpTheoremInfo 📋 Batteries.Tactic.Lint.Simp
: Type - Batteries.Tactic.Lint.simpComm 📋 Batteries.Tactic.Lint.Simp
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.simpNF 📋 Batteries.Tactic.Lint.Simp
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.simpVarHead 📋 Batteries.Tactic.Lint.Simp
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.SimpTheoremInfo.isConditional 📋 Batteries.Tactic.Lint.Simp
(self : Batteries.Tactic.Lint.SimpTheoremInfo) : Bool - Batteries.Tactic.Lint.SimpTheoremInfo.lhs 📋 Batteries.Tactic.Lint.Simp
(self : Batteries.Tactic.Lint.SimpTheoremInfo) : Lean.Expr - Batteries.Tactic.Lint.SimpTheoremInfo.rhs 📋 Batteries.Tactic.Lint.Simp
(self : Batteries.Tactic.Lint.SimpTheoremInfo) : Lean.Expr - Batteries.Tactic.Lint.isSimpTheorem 📋 Batteries.Tactic.Lint.Simp
(declName : Lean.Name) : Lean.MetaM Bool - Batteries.Tactic.Lint.SimpTheoremInfo.hyps 📋 Batteries.Tactic.Lint.Simp
(self : Batteries.Tactic.Lint.SimpTheoremInfo) : Array Lean.Expr - Batteries.Tactic.Lint.formatLemmas 📋 Batteries.Tactic.Lint.Simp
(usedSimps : Lean.Meta.Simp.UsedSimps) (simpName : String) : Lean.MetaM Lean.MessageData - Batteries.Tactic.Lint.isConditionalHyps 📋 Batteries.Tactic.Lint.Simp
(lhs : Lean.Expr) : List Lean.Expr → Lean.MetaM Bool - Batteries.Tactic.Lint.decorateError 📋 Batteries.Tactic.Lint.Simp
{α : Type} (msg : Lean.MessageData) (k : Lean.MetaM α) : Lean.MetaM α - Batteries.Tactic.Lint.SimpTheoremInfo.mk 📋 Batteries.Tactic.Lint.Simp
(hyps : Array Lean.Expr) (isConditional : Bool) (lhs rhs : Lean.Expr) : Batteries.Tactic.Lint.SimpTheoremInfo - Batteries.Tactic.Lint.isSimpEq 📋 Batteries.Tactic.Lint.Simp
(a b : Lean.Expr) (whnfFirst : Bool := true) : Lean.MetaM Bool - Batteries.Tactic.Lint.checkAllSimpTheoremInfos 📋 Batteries.Tactic.Lint.Simp
(ty : Lean.Expr) (k : Batteries.Tactic.Lint.SimpTheoremInfo → Lean.MetaM (Option Lean.MessageData)) : Lean.MetaM (Option Lean.MessageData) - Batteries.Tactic.Lint.withSimpTheoremInfos 📋 Batteries.Tactic.Lint.Simp
{α : Type} (ty : Lean.Expr) (k : Batteries.Tactic.Lint.SimpTheoremInfo → Lean.MetaM α) : Lean.MetaM (Array α) - Batteries.Tactic.Lint.SimpTheoremInfo.mk.injEq 📋 Batteries.Tactic.Lint.Simp
(hyps : Array Lean.Expr) (isConditional : Bool) (lhs rhs : Lean.Expr) (hyps✝ : Array Lean.Expr) (isConditional✝ : Bool) (lhs✝ rhs✝ : Lean.Expr) : ({ hyps := hyps, isConditional := isConditional, lhs := lhs, rhs := rhs } = { hyps := hyps✝, isConditional := isConditional✝, lhs := lhs✝, rhs := rhs✝ }) = (hyps = hyps✝ ∧ isConditional = isConditional✝ ∧ lhs = lhs✝ ∧ rhs = rhs✝) - Batteries.Tactic.Lint.SimpTheoremInfo.mk.sizeOf_spec 📋 Batteries.Tactic.Lint.Simp
(hyps : Array Lean.Expr) (isConditional : Bool) (lhs rhs : Lean.Expr) : sizeOf { hyps := hyps, isConditional := isConditional, lhs := lhs, rhs := rhs } = 1 + sizeOf hyps + sizeOf isConditional + sizeOf lhs + sizeOf rhs - Batteries.Tactic.Lint.impossibleInstance 📋 Batteries.Tactic.Lint.TypeClass
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.nonClassInstance 📋 Batteries.Tactic.Lint.TypeClass
: Batteries.Tactic.Lint.Linter - Batteries.Tactic.Lint.LintVerbosity 📋 Batteries.Tactic.Lint.Frontend
: Type - Batteries.Tactic.Lint.«command#lint+-*Only___» 📋 Batteries.Tactic.Lint.Frontend
: Lean.ParserDescr - Batteries.Tactic.Lint.«command#list_linters» 📋 Batteries.Tactic.Lint.Frontend
: Lean.ParserDescr - Batteries.Tactic.Lint.inProject 📋 Batteries.Tactic.Lint.Frontend
: Lean.ParserDescr - Batteries.Tactic.Lint.LintVerbosity.high 📋 Batteries.Tactic.Lint.Frontend
: Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.LintVerbosity.low 📋 Batteries.Tactic.Lint.Frontend
: Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.LintVerbosity.medium 📋 Batteries.Tactic.Lint.Frontend
: Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.instDecidableEqLintVerbosity 📋 Batteries.Tactic.Lint.Frontend
: DecidableEq Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.instInhabitedLintVerbosity 📋 Batteries.Tactic.Lint.Frontend
: Inhabited Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.instReprLintVerbosity 📋 Batteries.Tactic.Lint.Frontend
: Repr Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.LintVerbosity.ofNat 📋 Batteries.Tactic.Lint.Frontend
: ℕ → Batteries.Tactic.Lint.LintVerbosity - Batteries.Tactic.Lint.LintVerbosity.toCtorIdx 📋 Batteries.Tactic.Lint.Frontend
: Batteries.Tactic.Lint.LintVerbosity → ℕ - Batteries.Tactic.Lint.getAllDecls 📋 Batteries.Tactic.Lint.Frontend
: Lean.CoreM (Array Lean.Name) - Batteries.Tactic.Lint.getDeclsInCurrModule 📋 Batteries.Tactic.Lint.Frontend
: Lean.CoreM (Array Lean.Name) - Batteries.Tactic.Lint.getDeclsInPackage 📋 Batteries.Tactic.Lint.Frontend
(pkg : Lean.Name) : Lean.CoreM (Array Lean.Name) - Batteries.Tactic.Lint.LintVerbosity.ofNat_toCtorIdx 📋 Batteries.Tactic.Lint.Frontend
(x : Batteries.Tactic.Lint.LintVerbosity) : Batteries.Tactic.Lint.LintVerbosity.ofNat x.toCtorIdx = x - Batteries.Tactic.Lint.getChecks 📋 Batteries.Tactic.Lint.Frontend
(slow : Bool) (runOnly runAlways : Option (List Lean.Name)) : Lean.CoreM (Array Batteries.Tactic.Lint.NamedLinter) - Batteries.Tactic.Lint.groupedByFilename 📋 Batteries.Tactic.Lint.Frontend
(results : Std.HashMap Lean.Name Lean.MessageData) (useErrorFormat : Bool := false) : Lean.CoreM Lean.MessageData - Batteries.Tactic.Lint.sortResults 📋 Batteries.Tactic.Lint.Frontend
{α : Type} (results : Std.HashMap Lean.Name α) : Lean.CoreM (Array (Lean.Name × α)) - Batteries.Tactic.Lint.LintVerbosity.high.sizeOf_spec 📋 Batteries.Tactic.Lint.Frontend
: sizeOf Batteries.Tactic.Lint.LintVerbosity.high = 1 - Batteries.Tactic.Lint.LintVerbosity.low.sizeOf_spec 📋 Batteries.Tactic.Lint.Frontend
: sizeOf Batteries.Tactic.Lint.LintVerbosity.low = 1 - Batteries.Tactic.Lint.LintVerbosity.medium.sizeOf_spec 📋 Batteries.Tactic.Lint.Frontend
: sizeOf Batteries.Tactic.Lint.LintVerbosity.medium = 1 - Batteries.Tactic.Lint.printWarning 📋 Batteries.Tactic.Lint.Frontend
(declName : Lean.Name) (warning : Lean.MessageData) (useErrorFormat : Bool := false) (filePath : System.FilePath := default) : Lean.CoreM Lean.MessageData - Batteries.Tactic.Lint.lintCore 📋 Batteries.Tactic.Lint.Frontend
(decls : Array Lean.Name) (linters : Array Batteries.Tactic.Lint.NamedLinter) : Lean.CoreM (Array (Batteries.Tactic.Lint.NamedLinter × Std.HashMap Lean.Name Lean.MessageData)) - Batteries.Tactic.Lint.printWarnings 📋 Batteries.Tactic.Lint.Frontend
(results : Std.HashMap Lean.Name Lean.MessageData) (filePath : System.FilePath := default) (useErrorFormat : Bool := false) : Lean.CoreM Lean.MessageData - Batteries.Tactic.Lint.formatLinterResults 📋 Batteries.Tactic.Lint.Frontend
(results : Array (Batteries.Tactic.Lint.NamedLinter × Std.HashMap Lean.Name Lean.MessageData)) (decls : Array Lean.Name) (groupByFilename : Bool) (whereDesc : String) (runSlowLinters : Bool) (verbose : Batteries.Tactic.Lint.LintVerbosity) (numLinters : ℕ) (useErrorFormat : Bool := false) : Lean.CoreM Lean.MessageData - Batteries.CodeAction.TacticCodeAction 📋 Batteries.CodeAction.Attr
: Type - Batteries.CodeAction.TacticCodeActionEntry 📋 Batteries.CodeAction.Attr
: Type - Batteries.CodeAction.TacticCodeActions 📋 Batteries.CodeAction.Attr
: Type - Batteries.CodeAction.TacticSeqCodeAction 📋 Batteries.CodeAction.Attr
: Type - Batteries.CodeAction.tactic_code_action 📋 Batteries.CodeAction.Attr
: Lean.ParserDescr - Batteries.CodeAction.instInhabitedTacticCodeActionEntry 📋 Batteries.CodeAction.Attr
: Inhabited Batteries.CodeAction.TacticCodeActionEntry - Batteries.CodeAction.instInhabitedTacticCodeActions 📋 Batteries.CodeAction.Attr
: Inhabited Batteries.CodeAction.TacticCodeActions - Batteries.CodeAction.TacticCodeActionEntry.declName 📋 Batteries.CodeAction.Attr
(self : Batteries.CodeAction.TacticCodeActionEntry) : Lean.Name - Batteries.CodeAction.mkTacticCodeAction 📋 Batteries.CodeAction.Attr
(n : Lean.Name) : Lean.ImportM Batteries.CodeAction.TacticCodeAction - Batteries.CodeAction.mkTacticSeqCodeAction 📋 Batteries.CodeAction.Attr
(n : Lean.Name) : Lean.ImportM Batteries.CodeAction.TacticSeqCodeAction - Batteries.CodeAction.TacticCodeActionEntry.tacticKinds 📋 Batteries.CodeAction.Attr
(self : Batteries.CodeAction.TacticCodeActionEntry) : Array Lean.Name - Batteries.CodeAction.TacticCodeActions.onAnyTactic 📋 Batteries.CodeAction.Attr
(self : Batteries.CodeAction.TacticCodeActions) : Array Batteries.CodeAction.TacticCodeAction - Batteries.CodeAction.TacticCodeActionEntry.mk 📋 Batteries.CodeAction.Attr
(declName : Lean.Name) (tacticKinds : Array Lean.Name) : Batteries.CodeAction.TacticCodeActionEntry - Batteries.CodeAction.TacticCodeActions.onTactic 📋 Batteries.CodeAction.Attr
(self : Batteries.CodeAction.TacticCodeActions) : Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction) - Batteries.CodeAction.TacticCodeActions.insert 📋 Batteries.CodeAction.Attr
(self : Batteries.CodeAction.TacticCodeActions) (tacticKinds : Array Lean.Name) (action : Batteries.CodeAction.TacticCodeAction) : Batteries.CodeAction.TacticCodeActions - Batteries.CodeAction.TacticCodeActions.mk 📋 Batteries.CodeAction.Attr
(onAnyTactic : Array Batteries.CodeAction.TacticCodeAction) (onTactic : Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction)) : Batteries.CodeAction.TacticCodeActions - Batteries.CodeAction.mkTacticCodeAction.unsafe_1 📋 Batteries.CodeAction.Attr
(n : Lean.Name) (env : Lean.Environment) (opts : Lean.Options) : ExceptT String Id Batteries.CodeAction.TacticCodeAction - Batteries.CodeAction.mkTacticCodeAction.unsafe_impl_1 📋 Batteries.CodeAction.Attr
(n : Lean.Name) (env : Lean.Environment) (opts : Lean.Options) : ExceptT String Id Batteries.CodeAction.TacticCodeAction - Batteries.CodeAction.mkTacticSeqCodeAction.unsafe_1 📋 Batteries.CodeAction.Attr
(n : Lean.Name) (env : Lean.Environment) (opts : Lean.Options) : ExceptT String Id Batteries.CodeAction.TacticSeqCodeAction - Batteries.CodeAction.mkTacticSeqCodeAction.unsafe_impl_1 📋 Batteries.CodeAction.Attr
(n : Lean.Name) (env : Lean.Environment) (opts : Lean.Options) : ExceptT String Id Batteries.CodeAction.TacticSeqCodeAction - Batteries.CodeAction.tacticCodeActionExt 📋 Batteries.CodeAction.Attr
: Lean.PersistentEnvExtension Batteries.CodeAction.TacticCodeActionEntry (Batteries.CodeAction.TacticCodeActionEntry × Batteries.CodeAction.TacticCodeAction) (Array Batteries.CodeAction.TacticCodeActionEntry × Batteries.CodeAction.TacticCodeActions) - Batteries.CodeAction.tacticSeqCodeActionExt 📋 Batteries.CodeAction.Attr
: Lean.PersistentEnvExtension Lean.Name (Lean.Name × Batteries.CodeAction.TacticSeqCodeAction) (Array Lean.Name × Array Batteries.CodeAction.TacticSeqCodeAction) - Batteries.CodeAction.TacticCodeActionEntry.mk.injEq 📋 Batteries.CodeAction.Attr
(declName : Lean.Name) (tacticKinds : Array Lean.Name) (declName✝ : Lean.Name) (tacticKinds✝ : Array Lean.Name) : ({ declName := declName, tacticKinds := tacticKinds } = { declName := declName✝, tacticKinds := tacticKinds✝ }) = (declName = declName✝ ∧ tacticKinds = tacticKinds✝) - Batteries.CodeAction.TacticCodeActions.mk.injEq 📋 Batteries.CodeAction.Attr
(onAnyTactic : Array Batteries.CodeAction.TacticCodeAction) (onTactic : Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction)) (onAnyTactic✝ : Array Batteries.CodeAction.TacticCodeAction) (onTactic✝ : Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction)) : ({ onAnyTactic := onAnyTactic, onTactic := onTactic } = { onAnyTactic := onAnyTactic✝, onTactic := onTactic✝ }) = (onAnyTactic = onAnyTactic✝ ∧ onTactic = onTactic✝) - Batteries.CodeAction.TacticCodeActionEntry.mk.sizeOf_spec 📋 Batteries.CodeAction.Attr
(declName : Lean.Name) (tacticKinds : Array Lean.Name) : sizeOf { declName := declName, tacticKinds := tacticKinds } = 1 + sizeOf declName + sizeOf tacticKinds - Batteries.CodeAction.TacticCodeActions.mk.sizeOf_spec 📋 Batteries.CodeAction.Attr
(onAnyTactic : Array Batteries.CodeAction.TacticCodeAction) (onTactic : Lean.NameMap (Array Batteries.CodeAction.TacticCodeAction)) : sizeOf { onAnyTactic := onAnyTactic, onTactic := onTactic } = 1 + sizeOf onAnyTactic + sizeOf onTactic - Batteries.CodeAction.tacticCodeActionProvider 📋 Batteries.CodeAction.Basic
: Lean.Server.CodeActionProvider - Batteries.CodeAction.addSubgoalsAction 📋 Batteries.CodeAction.Misc
: Batteries.CodeAction.TacticCodeAction - Batteries.CodeAction.addSubgoalsSeqAction 📋 Batteries.CodeAction.Misc
: Batteries.CodeAction.TacticSeqCodeAction
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using (by default) Ctrl-K Ctrl-S. You can also try the
#loogle
command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
🔍Real.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
🔍"differ"
finds all lemmas that have"differ"
somewhere in their lemma name.By subexpression:
🔍_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
🔍Real.sqrt ?a * Real.sqrt ?a
If the pattern has parameters, they are matched in any order. Both of these will find
List.map
:
🔍(?a -> ?b) -> List ?a -> List ?b
🔍List ?a -> (?a -> ?b) -> List ?b
By main conclusion:
🔍|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all→
and∀
) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍|- _ < _ → tsum _ < tsum _
will findtsum_lt_tsum
even though the hypothesisf i < g i
is not the last.
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin
and tsum
, have "two"
as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _
(if
there were any such lemmas). Metavariables (?a
) are
assigned independently in each filter.
The #lucky
button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO.
This is Loogle revision 19971e9
serving mathlib revision bce1d65