name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Aesop.TreeRef.recOn | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
(t : Aesop.TreeRef) →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → motive t | null | false |
CategoryTheory.Monad.instInhabitedAlgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → (T : CategoryTheory.Monad C) → [Inhabited C] → Inhabited T.Algebra | null | true |
Std.Time.Month.instReprQuarter._aux_1 | Std.Time.Date.Unit.Month | Std.Time.Month.Quarter → ℕ → Std.Format | null | false |
Nat.prod_factorization_pow_eq_self | Mathlib.Data.Nat.Factorization.Defs | ∀ {n : ℕ}, n ≠ 0 → (n.factorization.prod fun x1 x2 => x1 ^ x2) = n | null | true |
CauSeq.const.congr_simp | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] (abv : β → α) [inst_4 : IsAbsoluteValue abv] (x x_1 : β),
x = x_1 → CauSeq.const abv x = CauSeq.const abv x_1 | null | true |
Sym | Mathlib.Data.Sym.Basic | Type u_1 → ℕ → Type (max 0 u_1) | The nth symmetric power is n-tuples up to permutation. We define it
as a subtype of `Multiset` since these are well developed in the
library. We also give a definition `Sym.sym'` in terms of vectors, and we
show these are equivalent in `Sym.symEquivSym'`.
| true |
Lean.Server.RefInfo.casesOn | Lean.Server.References | {motive : Lean.Server.RefInfo → Sort u} →
(t : Lean.Server.RefInfo) →
((definition : Option Lean.Server.Reference) →
(usages : Array Lean.Server.Reference) → motive { definition := definition, usages := usages }) →
motive t | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termI₃_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | null | true |
RelSeries.step | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (self : RelSeries r) (i : Fin self.length),
(self.toFun i.castSucc, self.toFun i.succ) ∈ r | Adjacent elements are related | true |
HomologicalComplex.mapBifunctor₁₂.ι_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Submonoid.pi_top | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι), (Submonoid.pi I fun i => ⊤) = ⊤ | null | true |
Std.Net.instDecidableEqIPv4Addr.decEq.match_1 | Std.Net.Addr | (motive : Std.Net.IPv4Addr → Std.Net.IPv4Addr → Sort u_1) →
(x x_1 : Std.Net.IPv4Addr) → ((a b : Vector UInt8 4) → motive { octets := a } { octets := b }) → motive x x_1 | null | false |
omegaToLiaRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | Debug `lia` by identifying places where it does not yet supersede `omega`. | true |
Equiv.Perm.ext | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ | null | true |
Quaternion.normSq_le_zero._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(Quaternion.normSq a ≤ 0) = (a = 0) | null | false |
CantorScheme.ClosureAntitone | Mathlib.Topology.MetricSpace.CantorScheme | {β : Type u_1} → {α : Type u_2} → (List β → Set α) → [TopologicalSpace α] → Prop | A useful strengthening of being antitone is to require that each set contains
the closure of each of its children. | true |
List.foldrM_filterMap | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → Option β} {g : β → γ → m γ} {l : List α} {init : γ},
List.foldrM g init (List.filterMap f l) =
List.foldrM
(fun x y =>
match f x with
| some b => g b y
| none => pure ... | null | true |
Std.HashMap.Raw.getKey!_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] {a : α} {c : ℕ},
(Std.HashMap.Raw.emptyWithCapacity c).getKey! a = default | null | true |
CategoryTheory.Functor.HomObj.comp_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)} {M : CategoryTheory.Functor C D}
(f : F.HomObj G A) (g : G.HomObj M A) (X : C) (a : A.obj X),
(f.comp g).app X a = Categor... | null | true |
Rat.natCast_le_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℕ} {n : ℚ}, (↑m ≤ ↑n) = (↑m ≤ n) | null | false |
ONote._sizeOf_1 | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ | null | false |
Lean.Meta.Grind.EMatchDiagInfo.casesOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.EMatchDiagInfo → Sort u} →
(t : Lean.Meta.Grind.EMatchDiagInfo) →
((lctx : Lean.LocalContext) →
(sources : List Lean.Meta.Grind.EMatchDiagNode) →
(target : Lean.Meta.Grind.EMatchDiagNode) → motive { lctx := lctx, sources := sources, target := target }) →
motive t | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.caching.unsafe_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {α : Type u_1} → α → UInt64 | null | true |
_private.Mathlib.FieldTheory.Separable.0.Polynomial.separable_of_subsingleton._simp_1_2 | Mathlib.FieldTheory.Separable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
Vector.exists_of_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {b : β} {xs : Vector α n} {f : α → Vector β m},
b ∈ xs.flatMap f → ∃ a ∈ xs, b ∈ f a | null | true |
Fin.Value.mk.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ (n : ℕ) (value : Fin n) (n_1 : ℕ) (value_1 : Fin n_1),
({ n := n, value := value } = { n := n_1, value := value_1 }) = (n = n_1 ∧ value ≍ value_1) | null | true |
NumberField.recOn | Mathlib.NumberTheory.NumberField.Basic | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField K → Sort u} →
(t : NumberField K) →
([to_charZero : CharZero K] → [to_finiteDimensional : FiniteDimensional ℚ K] → motive ⋯) → motive t | null | false |
NonemptyFinLinOrd._sizeOf_1 | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd → ℕ | null | false |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.exists_hasPrimitiveVectorWith._simp_1_2 | Mathlib.Algebra.Lie.Sl2 | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
nhds_le_nhdsSet | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X} {x : X}, x ∈ s → nhds x ≤ nhdsSet s | null | true |
Matroid.spanning_iff_compl_coindep | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {S : Set α},
autoParam (S ⊆ M.E) Matroid.spanning_iff_compl_coindep._auto_1 → (M.Spanning S ↔ M.Coindep (M.E \ S)) | null | true |
NumberField.Units.dirichletUnitTheorem.mult_log_place_eq_zero | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] {x : (NumberField.RingOfIntegers K)ˣ} {w : NumberField.InfinitePlace K},
↑w.mult * Real.log (w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x)) = 0 ↔
w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x) = 1 | null | true |
Array.getElem_shrink._proof_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, j < (xs.shrink i).size → j < xs.size | null | false |
Module.Presentation.tautological.R.recOn | Mathlib.Algebra.Module.Presentation.Tautological | {A : Type u} →
{M : Type v} →
{motive : Module.Presentation.tautological.R A M → Sort u_1} →
(t : Module.Presentation.tautological.R A M) →
((m₁ m₂ : M) → motive (Module.Presentation.tautological.R.add m₁ m₂)) →
((a : A) → (m : M) → motive (Module.Presentation.tautological.R.smul a m)) → m... | null | false |
List.Perm.length_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → l₁.length = l₂.length | null | true |
CategoryTheory.Limits.ChosenPullback.p₂ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} → {f₂ : X₂ ⟶ S} → (self : CategoryTheory.Limits.ChosenPullback f₁ f₂) → self.pullback ⟶ X₂ | the second projection | true |
CategoryTheory.ObjectProperty.prop_cokernel | Mathlib.CategoryTheory.ObjectProperty.Kernels | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderCokernels] {X Y : C} (f : X ⟶ Y)
[inst_3 : CategoryTheory.Limits.HasCokernel f], P X → P Y → P (CategoryTheory.Limits.cokernel f) | null | true |
String.Pos.find?_char_eq_some_iff._proof_1 | Init.Data.String.Lemmas.Pattern.Find.Char | ∀ {s : String} {pos' : s.Pos}, ∀ pos'' < pos', pos'' ≠ s.endPos | null | false |
Equiv.vadd | Mathlib.Algebra.Group.TransferInstance | (M : Type u_1) → {α : Type u_2} → {β : Type u_3} → α ≃ β → [VAdd M β] → VAdd M α | Transfer `VAdd` across an `Equiv` | true |
CategoryTheory.ShortComplex.homologyι_naturality | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
Ca... | null | true |
Lean.JsonRpc.MessageDirection.toCtorIdx | Lean.Data.JsonRpc | Lean.JsonRpc.MessageDirection → ℕ | null | false |
isCoprime_mul_units_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R},
IsUnit u → IsUnit v → ∀ (y z : R), IsCoprime (y * u) (z * v) ↔ IsCoprime y z | null | true |
_private.Init.Data.List.Attach.0.List.pmap_eq_pmapImpl.match_1_1 | Init.Data.List.Attach | (α : Type u_1) →
(p : α → Prop) →
(motive : Subtype p → Sort u_2) → (x : Subtype p) → ((x : α) → (hx : p x) → motive ⟨x, hx⟩) → motive x | null | false |
Std.Rxi.Iterator.toList_eq_match | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{it : Std.Iter α},
it.toList =
match it.internalState.next with
| none => []
| some a => a :: { internalState := { next := Std.PRange.succ? a } }.toList | null | true |
Path.Homotopy.reflTransSymmAux_mem_I | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (x : ↑unitInterval × ↑unitInterval), Path.Homotopy.reflTransSymmAux x ∈ unitInterval | null | true |
IsStrictOrder.toIsTrans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsStrictOrder α r], IsTrans α r | null | true |
_private.Mathlib.Analysis.Complex.Polynomial.GaussLucas.0.Polynomial.eq_centerMass_of_eval_derivative_eq_zero._simp_1_12 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
CoassocSimps.symm_comp_rid_symm_assoc | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} {M : Type u_3} {M' : Type u_6} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
↑(TensorProduct.comm R M' R) ∘ₗ ↑(TensorProduct.rid R M').symm ∘ₗ f = ↑(TensorProduct.lid R M').symm ∘ₗ f | null | true |
measurable_of_countable | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [Countable α]
[MeasurableSingletonClass α] (f : α → β), Measurable f | null | true |
Set.powersetCard.addAction_faithful | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_2} [inst : DecidableEq α] {G : Type u_3} [inst_1 : AddGroup G] [inst_2 : AddAction G α] {n : ℕ},
1 ≤ n → ↑n < ENat.card α → ∀ {g : G}, AddAction.toPerm g = 1 ↔ AddAction.toPerm g = 1 | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : σ →₀ ℕ)
(φ : MvPowerSeries σ R), f ((MvPowerSeries.coeff n) φ) = (MvPowerSeries.coeff n) ((MvPowerSeries.map f) φ) | null | false |
Set.mapsTo_id | Mathlib.Data.Set.Function | ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s | null | true |
_private.Init.Data.List.Impl.0.List.takeWhileTR.go | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α | Auxiliary for `takeWhile`: `takeWhile.go p l xs acc = acc.toList ++ takeWhile p xs`,
unless no element satisfying `p` is found in `xs` in which case it returns `l`. | true |
Polynomial.X_pow_sub_one_separable_iff | Mathlib.FieldTheory.Separable | ∀ {F : Type u} [inst : Field F] {n : ℕ}, (Polynomial.X ^ n - 1).Separable ↔ ↑n ≠ 0 | In a field `F`, `X ^ n - 1` is separable iff `↑n ≠ 0`. | true |
Complex.ofReal_comp_pow | Mathlib.Data.Complex.Basic | ∀ {α : Type u_1} (f : α → ℝ) (n : ℕ), Complex.ofReal ∘ (f ^ n) = Complex.ofReal ∘ f ^ n | null | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.isColimitGluedCocone._proof_6 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | null | false |
Matroid.Nonempty.casesOn | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} →
{M : Matroid α} →
{motive : M.Nonempty → Sort u} → (t : M.Nonempty) → ((ground_nonempty : M.E.Nonempty) → motive ⋯) → motive t | null | false |
Std.Time.Week.Offset.toHours | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Hour.Offset | Convert `Week.Offset` into `Hour.Offset`.
| true |
List.forall_iff_forall_mem | Mathlib.Data.List.Basic | ∀ {α : Type u} {p : α → Prop} {l : List α}, List.Forall p l ↔ ∀ x ∈ l, p x | null | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.eigenspace_restrict_le_eigenspace._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CategoryTheory.Lax.LaxTrans.id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → (F : CategoryTheory.LaxFunctor B C) → CategoryTheory.Lax.LaxTrans F F | The identity lax transformation. | true |
PreOpposite.op'.inj | Mathlib.Algebra.Opposites | ∀ {α : Type u_3} {unop' unop'_1 : α}, { unop' := unop' } = { unop' := unop'_1 } → unop' = unop'_1 | null | true |
Lean.Elab.Modifiers.mk | Lean.Elab.DeclModifiers | Lean.TSyntax `Lean.Parser.Command.declModifiers →
Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) →
Lean.Elab.Visibility →
Bool → Lean.Elab.ComputeKind → Lean.Elab.RecKind → Bool → Array Lean.Elab.Attribute → Lean.Elab.Modifiers | null | true |
LieSubmodule.gi._proof_2 | Mathlib.Algebra.Lie.Submodule | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : Set M),
↑(LieSubmodule.lieSpan R L x) ≤ x → LieSubmodule.lieSpan R L x = LieSubmodule.lieSpan R L x | null | false |
Std.TreeSet.foldrM_eq_foldrM_toList | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m δ} {init : δ}, Std.TreeSet.foldrM f init t = List.foldrM f init t.toList | null | true |
_private.Mathlib.CategoryTheory.Iso.0.CategoryTheory.Iso.cancel_iso_hom_right_assoc._simp_1_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] {g h : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) | null | false |
TensorProduct.leftHasSMul | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R' : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Monoid R'] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : DistribMulAction R' M] →
[inst_5 : Module R ... | Given two modules over a commutative semiring `R`, if one of the factors carries a
(distributive) action of a second type of scalars `R'`, which commutes with the action of `R`, then
the tensor product (over `R`) carries an action of `R'`.
This instance defines this `R'` action in the case that it is the left module w... | true |
TestFunctionClass.noConfusionType | Mathlib.Analysis.Distribution.TestFunction | Sort u →
{B : Type u_6} →
{E : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_8} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
... | null | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.mvarsOutputParams.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.PreprocessKind.mvarsOutputParams✝ = 1 | null | true |
CategoryTheory.ShortComplex.Homotopy.refl_h₁ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂), (CategoryTheory.ShortComplex.Homotopy.refl φ).h₁ = 0 | null | true |
DirectLimit.instAddMonoid._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → AddMonoid (G i)] [∀ (i j : ι) (h : i ≤ j), AddMonoidHomClass (T h) (G i) (G j)] (n : ℕ)
(x x_1 : ι) ... | null | false |
Asymptotics.IsLittleO.sub | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ : α → E'}, f₁ =o[l] g → f₂ =o[l] g → (fun x => f₁ x - f₂ x) =o[l] g | null | true |
Int.sub_lt_sub_right_iff._simp_1 | Init.Data.Int.Order | ∀ {a b c : ℤ}, (a - c < b - c) = (a < b) | null | false |
CategoryTheory.Abelian.Ext.homEquiv₀_symm_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (a : X ⟶ Y),
CategoryTheory.Abelian.Ext.homEquiv₀.symm a = CategoryTheory.Abelian.Ext.mk₀ a | null | true |
Lean.Grind.NoopConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.NoopConfig → Lean.Grind.NoopConfig → Sort u | null | false |
AddCommute.map | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddCommute x y → ∀ (f : F), AddCommute (f x) (f y) | null | true |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.tryAutoCongrTheorem?._proof_1 | Lean.Meta.Tactic.Simp.Types | ∀ (__do_lift : Lean.Meta.FunInfo) (config : Lean.Meta.Simp.Config)
(__s : Bool × Bool × Bool × Array Lean.Expr × Array Lean.Meta.Simp.Result × ℕ × Subarray Lean.Meta.CongrArgKind),
config.ground = true ∧ __s.2.2.2.2.2.1 < __do_lift.paramInfo.size → __s.2.2.2.2.2.1 < __do_lift.paramInfo.size | null | false |
PNat.toPNat'_coe | Mathlib.Data.PNat.Defs | ∀ {n : ℕ}, 0 < n → ↑n.toPNat' = n | null | true |
_private.Mathlib.Order.Defs.PartialOrder.0.le_antisymm_iff.match_1_1 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} (motive : a ≤ b ∧ b ≤ a → Prop) (x : a ≤ b ∧ b ≤ a),
(∀ (h1 : a ≤ b) (h2 : b ≤ a), motive ⋯) → motive x | null | false |
CategoryTheory.JointlyFaithful | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_4, u_1} C] →
{I : Type u_2} →
{D : I → Type u_3} →
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] →
((i : I) → CategoryTheory.Functor C (D i)) → Prop | A family of functors is jointly faithful if whenever two morphisms `f : X ⟶ Y`
and `g : X ⟶ Y` become equal after applying all functors `F i`, then `f = g`. | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties.0.AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f =
∀ (U : ↑Y.affineOpens) (V : ↑X.affineOpens) (e : ↑V ≤ (TopologicalSpace.Opens.map f.base).obj ↑U),
... | null | false |
WeierstrassCurve.Jacobian.Point.toAffineLift_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F} (hP : W.NonsingularLift ⟦P⟧),
P 2 = 0 → { point := ⟦P⟧, nonsingular := hP }.toAffineLift = 0 | null | true |
Lean.Elab.ConfigEval.EvalConfigItemHandlerKind._sizeOf_1 | Lean.Elab.ConfigEval.DeriveEvalConfigItem | Lean.Elab.ConfigEval.EvalConfigItemHandlerKind → ℕ | null | false |
strictConvexOn_of_deriv2_pos | Mathlib.Analysis.Convex.Deriv | ∀ {D : Set ℝ},
Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, 0 < deriv^[2] f x) → StrictConvexOn ℝ D f | If a function `f` is continuous on a convex set `D ⊆ ℝ` and `f''` is strictly positive on the
interior, then `f` is strictly convex on `D`.
Note that we don't require twice differentiability explicitly as it is already implied by the second
derivative being strictly positive, except at at most one point. | true |
Set.singleton_subset_singleton._gcongr_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {a b : α}, a = b → {a} ⊆ {b} | null | false |
CategoryTheory.Monad.forgetCreatesColimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
[CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₁, u₁, u₁} T.toFunctor] →
CategoryTheory.CreatesColimitsOfSize.{v, u, v₁, v₁, max u₁ v₁, u₁} T.forget | null | true |
USize.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin USize.size), (USize.ofFin x).toNat = ↑x | null | true |
Ring.instIsDomainNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S], IsDomain (Ring.NormalClosure R S) | null | true |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_3 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ | null | false |
Orientation.oangle_sign_sub_smul_left | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (r : ℝ), (o.oangle (x - r • y) y).sign = (o.oangle x y).sign | Subtracting a multiple of the second vector passed to `oangle` from the first vector does
not change the sign of the angle. | true |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.lMask | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → BitVec cfg.wordSize | null | true |
Lean.Environment.imports | Lean.Environment | Lean.Environment → Array Lean.Import | null | true |
Std.Internal.List.maxKey!_insertEntryIfNew | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k},
Std.Internal.List.maxKey! (Std.Internal.List.insertEntryIfNew k v l) =
(Std.Internal.List... | null | true |
Lean.Level.PP.Result.maxNode.noConfusion | Lean.Level | {P : Sort u} →
{a a' : List Lean.Level.PP.Result} →
Lean.Level.PP.Result.maxNode a = Lean.Level.PP.Result.maxNode a' → (a = a' → P) → P | null | false |
_private.Mathlib.Algebra.Ring.GeomSum.0.geom_sum₂_mul_of_le._simp_1_1 | Mathlib.Algebra.Ring.GeomSum | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Mathlib.Tactic.FieldSimp.Sign.mul.match_1 | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.Sign M → Mathlib.Tactic.FieldSimp.Sign M → Sort u_1) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
(Unit → motive Mathlib.Tactic.FieldSimp.Sign.plus Mathlib.Tactic.FieldSimp.Sign.plus) →
((i : Q(Field «$M»)) → motive M... | null | false |
HahnEmbedding.Seed.mk.sizeOf_spec | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | null | true |
Std.HashMap.Raw.distinct_keys | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → List.Pairwise (fun a b => (a == b) = false) m.keys | null | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_6 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules) (f : (↑R)ᵒᵖ)
(x : ↥(Submonoid.powers (Opposite.unop f))),
IsUnit
((algebraMap (↑R)
(Module.End ↑R
↑((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj
(Opposite.op ((CategoryTheory.inducedFunctor Pri... | null | false |
Std.DTreeMap.minKeyD_le_minKeyD_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t.erase k).isEmpty = false → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.