name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.InducedCategory.Hom.mk | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (F X ⟶ F Y) → X.Hom Y | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(motive : (Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) → Sort u_3) →
(step : Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) →
((ky : α) →
(a : Ordering.lt = Ordering.lt) →
... | null | true |
Std.DTreeMap.Internal.Impl.length_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.keys.length = t.size | null | true |
_private.Aesop.RuleTac.Cases.0.Aesop.RuleTac.cases.go.match_10 | Aesop.RuleTac.Cases | (motive : Option (Array Lean.Meta.CasesSubgoal) → Sort u_1) →
(__x : Option (Array Lean.Meta.CasesSubgoal)) →
((goals : Array Lean.Meta.CasesSubgoal) → motive (some goals)) →
((x : Option (Array Lean.Meta.CasesSubgoal)) → motive x) → motive __x | null | false |
AlgebraicGeometry.Scheme.PartialMap.comp_assoc | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {X₁ X₂ X₃ Y : AlgebraicGeometry.Scheme} [inst : PreirreducibleSpace ↥X₁] [inst_1 : IrreducibleSpace ↥X₂]
[inst_2 : Nonempty ↥X₃] (f : X₁.PartialMap X₂) [inst_3 : AlgebraicGeometry.IsDominant f.hom] (g : X₂.PartialMap X₃)
[inst_4 : AlgebraicGeometry.IsDominant g.hom] (h : X₃.PartialMap Y), (f.comp g).comp h = f.co... | null | true |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstr?.match_1 | Lean.Meta.Tactic.Simp.Arith.Nat.Simp | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__x : Option (Lean.Expr × Lean.Expr)) →
((eNew' h₂ : Lean.Expr) → motive (some (eNew', h₂))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __x | null | false |
List.getLast._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1}, [] = [] | null | false |
MeasureTheory.Measure.AbsolutelyContinuous.support_mono | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ ν : MeasureTheory.Measure X},
μ.AbsolutelyContinuous ν → μ.support ⊆ ν.support | null | true |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.nz_of_isRat.match_1_1 | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [inst : Ring A]
(motive : Mathlib.Meta.NormNum.IsRat e n d → decide (n < 0) = true → Prop) (x : Mathlib.Meta.NormNum.IsRat e n d)
(x_1 : decide (n < 0) = true),
(∀ (inv : Invertible ↑d) (eq : e = ↑n * ⅟↑d) (h : decide (n < 0) = true), motive ⋯ h) → motive x x_1 | null | false |
FiniteField.frobenius_pow | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p : ℕ} [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP K p]
{n : ℕ}, Fintype.card K = p ^ n → frobenius K p ^ n = 1 | null | true |
IsDiscreteValuationRing.unit_mul_pow_congr_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsDiscreteValuationRing R] {ϖ : R},
Irreducible ϖ → ∀ (u v : Rˣ) (m n : ℕ), ↑u * ϖ ^ m = ↑v * ϖ ^ n → u = v | null | true |
ContinuousLinearEquiv.toDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(e : E ≃L[𝕜] E'), ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') ↑⊤ ⇑e | null | false |
Fin.foldrM_succ | Init.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] (f : Fin (n + 1) → α → m α),
Fin.foldrM (n + 1) f = fun x => Fin.foldrM n (fun i => f i.succ) x >>= f 0 | null | true |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.inf_dite_neg_le._proof_1_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} (p : β → Prop)
[inst_2 : DecidablePred p] {f : (b : β) → p b → α} {g : (b : β) → ¬p b → α} {b : β},
b ∈ s → ∀ (h₁ : ¬p b), (s.inf fun i => if h : p i then f i h else g i h) ≤ g b h₁ | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.error.noConfusion | Mathlib.Tactic.TacticAnalysis.Declarations | {P : Sort u} →
{stx : Lean.TSyntax `tactic} →
{msg : Lean.MessageData} →
{stx' : Lean.TSyntax `tactic} →
{msg' : Lean.MessageData} →
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝ stx msg =
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝ stx' msg' →
... | null | false |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} {E : ι → Type u_3} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)],
ContinuousAdd (PiTensorProduct 𝕜 fun i => E i) | null | false |
Filter.CountableGenerateSets.below.basic | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_2} {g : Set (Set α)} {motive : (a : Set α) → Filter.CountableGenerateSets g a → Prop} {s : Set α}
(a : s ∈ g), Filter.CountableGenerateSets.below ⋯ | null | true |
DirectSum.GSemiring.casesOn | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : AddMonoid ι] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
{motive : DirectSum.GSemiring A → Sort u} →
(t : DirectSum.GSemiring A) →
([toGNonUnitalNonAssocSemiring : DirectSum.GNonUnitalNonAssocSemiring A] →
[toGOne :... | null | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_13 | Lean.Elab.Tactic.Simp | (motive : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(x : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult) →
((ref : Lean.Syntax) → (arg : Lean.Elab.Tactic.ElabSimpArgResult) → motive (ref, arg)) → motive x | null | false |
Std.Tactic.BVDecide.LRAT.Internal.lratChecker._unsafe_rec | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | {α : Type u_1} →
{β : Type u_2} →
{σ : Type u_3} →
[DecidableEq α] →
[inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] →
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] →
[Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] →
σ → List (Std.Tactic.BVDecid... | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_iff_forall_isSome_getEntry?.match_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Prop) (x : List ((a : α) × β a)),
(∀ (_ : Unit), motive []) → (∀ (k : α) (v : β k) (l : List ((a : α) × β a)), motive (⟨k, v⟩ :: l)) → motive x | null | false |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (L : List M) (n : ℕ) (a : M),
(L.set n a).sum = ((List.take n L).sum + if n < L.length then a else 0) + (List.drop (n + 1) L).sum | null | true |
CategoryTheory.Functor.PushoutObjObj.ofNatIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{X₁... | Transport a `Functor.PushoutObjObj` structure via a natural isomorphism of functors. | true |
Finset.piecewise | Mathlib.Data.Finset.Piecewise | {ι : Type u_1} →
{π : ι → Sort u_2} →
(s : Finset ι) → ((i : ι) → π i) → ((i : ι) → π i) → [(j : ι) → Decidable (j ∈ s)] → (i : ι) → π i | `s.piecewise f g` is the function equal to `f` on the finset `s`, and to `g` on its
complement. | true |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {A : Type u_3} {C : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (c : C),
(WithConv.ofConv 1) c = (algebraMap R A) (CoalgebraStruct.counit c) | null | true |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} → Lean.IR.IRType → Sort (max 1 u) | null | false |
AbstractSimplicialComplex.mk | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {ι : Type u_1} →
(toPreAbstractSimplicialComplex : PreAbstractSimplicialComplex ι) →
(∀ (v : ι), {v} ∈ toPreAbstractSimplicialComplex.faces) → AbstractSimplicialComplex ι | null | true |
_private.Mathlib.NumberTheory.ModularForms.Discriminant.0.ModularForm.discriminant_eq_q_prod._simp_1_3 | Mathlib.NumberTheory.ModularForms.Discriminant | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (n • x) | null | false |
PhragmenLindelof.eq_zero_on_quadrant_IV | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E},
DiffContOnCl ℂ f (Set.Ioi 0 ×ℂ Set.Iio 0) →
(∃ c < 2,
∃ B, f =O[Bornology.cobounded ℂ ⊓ Filter.principal (Set.Ioi 0 ×ℂ Set.Iio 0)] fun z => Real.exp (B * ‖z‖ ^ c)) →
(∀ (x : ℝ), 0 ≤ x → f ↑x = 0) → (∀ x ≤ 0, f (↑x... | **Phragmen-Lindelöf principle** in the fourth quadrant. Let `f : ℂ → E` be a function such that
* `f` is differentiable in the open fourth quadrant and is continuous on its closure;
* `‖f z‖` is bounded from above by `A * exp(B * ‖z‖ ^ c)` on the open fourth quadrant
for some `A`, `B`, and `c < 2`;
* `f` is equal to... | true |
_private.Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno.0.OrderedFinpartition.eraseMiddle._simp_5 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) | null | false |
IsTopologicalRing.toIsSemitopologicalRing | Mathlib.Topology.Algebra.Ring.Basic | ∀ (R : Type u_2) [inst : TopologicalSpace R] [inst_1 : NonUnitalNonAssocRing R] [IsTopologicalRing R],
IsSemitopologicalRing R | null | true |
_private.Mathlib.Topology.Order.LeftRightLim.0.Monotone.leftLim_le._simp_1_4 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
instRingWithIdealFilter._proof_7 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A) (a : WithIdealFilter x), a + 0 = a | null | false |
Monotone.withTop_map | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Monotone f → Monotone (WithTop.map f) | **Alias** of the reverse direction of `WithTop.monotone_map_iff`. | true |
npow_mul_comm | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (m n : ℕ) (x : M),
x ^ m * x ^ n = x ^ n * x ^ m | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | null | true |
MonCat.Colimits.quot_one | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one = 1 | null | true |
IsLocalHomeomorphOn.of_comp_left | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {g : Y → Z} {f : X → Y} {s : Set X},
IsLocalHomeomorphOn (g ∘ f) s → IsLocalHomeomorphOn g (f '' s) → (∀ x ∈ s, ContinuousAt f x) → IsLocalHomeomorphOn f s | null | true |
Localization.algEquiv_symm_mk | Mathlib.RingTheory.Localization.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
(Localization.algEquiv M S).symm (IsLocalization.mk' S x y) = Localization.mk x y | null | true |
String.ofList._proof_1 | Init.Prelude | ∀ (data : List Char), data.utf8Encode.IsValidUTF8 | null | false |
AddChar.PrimitiveAddChar.char | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | {R : Type u} →
[inst : CommRing R] →
{R' : Type v} →
[inst_1 : Field R'] → (self : AddChar.PrimitiveAddChar R R') → AddChar R (CyclotomicField (↑self.n) R') | The second projection from `PrimitiveAddChar`, giving the character. | true |
_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State.ctorIdx | Lean.Util.CollectAxioms | Lean.CollectAxioms.State✝ → ℕ | null | false |
_private.Mathlib.AlgebraicGeometry.OrderOfVanishing.0.AlgebraicGeometry.Scheme.ord_le_smul._simp_1_6 | Mathlib.AlgebraicGeometry.OrderOfVanishing | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsIntegral X] {U : X.Opens} (x : ↥X) (hx : x ∈ U),
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (X.presheaf.germ U x hx)) = True | null | false |
_private.Mathlib.LinearAlgebra.Contraction.0.dualTensorHom_bijective._simp_1_1 | Mathlib.LinearAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (g : P →ₗ[R] Q)
(... | null | false |
Subfield.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] {X : Type u_1} [inst_1 : MulAction K X] (b : X), 1 • b = b | null | false |
skyscraperSheafForgetAdjunction | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
[inst_3 : CategoryTheory.Limits.HasColimits C] →
TopCat.Preshea... | Taking stalks is the left adjoint of `skyscraperSheafFunctor ⋙ Sheaf.forget`. Useful
only when the fact that `skyscraperPresheafFunctor` factors through `Sheaf C X` is relevant. | true |
CategoryTheory.Limits.biprod.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X X_1 : C) (e_X : X = X_1) (Y Y_1 : C) (e_Y : Y = Y_1) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
(X ⊞ Y) = (X_1 ⊞ Y_1) | null | true |
MulEquiv.coe_subgroupMap_apply | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (e : G ≃* G') (H : Subgroup G) (g : ↥H),
↑((e.subgroupMap H) g) = e ↑g | null | true |
Std.Time.FormatType | Std.Time.Format.Basic | Type → Std.Time.FormatString → Type | null | true |
Polynomial.expand_eq_zero | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] {p : ℕ}, 0 < p → ∀ {f : Polynomial R}, (Polynomial.expand R p) f = 0 ↔ f = 0 | null | true |
MeasureTheory.measureReal_univ_pos | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] [NeZero μ],
0 < μ.real Set.univ | null | true |
LieModuleHom.codRestrict.congr_simp | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : LieRingModule L N] (P : LieSubmodule R L N) (f f_1 : M →ₗ⁅R,L⁆ N) (e_f : f = f_1)
(... | null | true |
List.SortedGT.reverse | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGT → l.reverse.SortedLT | **Alias** of the reverse direction of `List.sortedLT_reverse`. | true |
instIsLeftCancelSMulOfIsLeftCancelMul | Mathlib.Algebra.Group.Action.Defs | ∀ (G : Type u_9) [inst : Mul G] [IsLeftCancelMul G], IsLeftCancelSMul G G | null | true |
Matrix.addGroup._proof_4 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : AddGroup α],
autoParam (∀ (n_1 : ℕ) (a : Matrix m n α), Int.negSucc n_1 • a = -(↑n_1.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
Std.ExtDTreeMap.Const.isSome_get?_iff_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{a : α}, (Std.ExtDTreeMap.Const.get? t a).isSome = true ↔ a ∈ t | null | true |
CategoryTheory.End.smul_left | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {r : (CategoryTheory.End X)ᵐᵒᵖ} {f : X ⟶ Y},
r • f = CategoryTheory.CategoryStruct.comp (MulOpposite.unop r) f | null | true |
StarAddMonoid.mk | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : AddMonoid R] →
[toInvolutiveStar : InvolutiveStar R] → (∀ (r s : R), star (r + s) = star r + star s) → StarAddMonoid R | null | true |
IsIntegrallyClosed.of_iInf_eq_bot | Mathlib.RingTheory.LocalProperties.IntegrallyClosed | ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{ι : Type u_3} (S : ι → Subalgebra R K), (∀ (i : ι), IsIntegrallyClosed ↥(S i)) → ⨅ i, S i = ⊥ → IsIntegrallyClosed R | null | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._proof_6 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._auto_1 → k + 1 + 2 ≤ n + 3 | null | false |
CategoryTheory.MonoOver.supLe._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasBinaryCoproducts C] {A : C}
(f g : CategoryTheory.MonoOver A), CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.pair f.obj.left g.obj.left) | null | false |
_private.Lean.Message.0.Lean.MessageData.hasSyntheticSorry.visit._sparseCasesOn_1 | Lean.Message | {motive_1 : Lean.MessageData → Sort u} →
(t : Lean.MessageData) →
((f : Option Lean.PPContext → BaseIO Dynamic) →
(hasSyntheticSorry : Lean.MetavarContext → Bool) → motive_1 (Lean.MessageData.ofLazy f hasSyntheticSorry)) →
((a : Lean.MessageDataContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.Me... | null | false |
CategoryTheory.Functor.instIsTriangulatedPlusMapHomotopyCategoryPlus | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive]
[inst_5 : CategoryTheory.Limits.HasZeroObject C] [ins... | null | true |
conjneg_ne_zero | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 0 ↔ f ≠ 0 | null | true |
Lean.Elab.FieldRedeclInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.FieldRedeclInfo → Sort u} →
(t : Lean.Elab.FieldRedeclInfo) → ((stx : Lean.Syntax) → motive { stx := stx }) → motive t | null | false |
Multiset.disjoint_finset_sum_left | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} {i : Finset ι} {f : ι → Multiset α} {a : Multiset α},
Disjoint (i.sum f) a ↔ ∀ b ∈ i, Disjoint (f b) a | **Alias** of `Multiset.disjoint_finsetSum_left`. | true |
Finsupp.mem_range_mapDomain_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α → β),
Function.Injective f → ∀ (x : β →₀ M), x ∈ Set.range (Finsupp.mapDomain f) ↔ ∀ b ∉ Set.range f, x b = 0 | null | true |
_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive | Lean.Elab.PreDefinition.Main | Lean.Elab.PreDefinition → Bool | null | true |
Num.pos.injEq | Mathlib.Data.Num.Basic | ∀ (a a_1 : PosNum), (Num.pos a = Num.pos a_1) = (a = a_1) | null | true |
Function.FromTypes | Mathlib.Logic.Function.FromTypes | {n : ℕ} → (Fin n → Type u) → Type u → Type u | The type of `n`-ary functions `p 0 → p 1 → ... → p (n - 1) → τ`. | true |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TuringMachine.Config | DecidableEq Turing.ToPartrec.Code | null | true |
_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState.output.injEq | Lean.Server.FileWorker.ExampleHover | ∀ (indent ticks indent_1 ticks_1 : ℕ),
(Lean.Server.FileWorker.Hover.RWState.output✝ indent ticks =
Lean.Server.FileWorker.Hover.RWState.output✝ indent_1 ticks_1) =
(indent = indent_1 ∧ ticks = ticks_1) | null | true |
Std.Async.TCP.Socket.Client.noConfusion | Std.Async.TCP | {P : Sort u} → {t t' : Std.Async.TCP.Socket.Client} → t = t' → Std.Async.TCP.Socket.Client.noConfusionType P t t' | null | false |
Lean.Elab.Term.elabStateRefT | Lean.Elab.BuiltinNotation | Lean.Elab.Term.TermElab | null | true |
CompactlyCoherentSpace.casesOn | Mathlib.Topology.Compactness.CompactlyCoherentSpace | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : CompactlyCoherentSpace X → Sort u} →
(t : CompactlyCoherentSpace X) →
((isCoherentWith : Topology.IsCoherentWith {K | IsCompact K}) → motive ⋯) → motive t | null | false |
Real.instFloorRing | Mathlib.Algebra.Order.Archimedean.Real.Basic | FloorRing ℝ | null | true |
Std.DTreeMap.Equiv.foldrM_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m δ} {init : δ},
t₁.Equiv t₂ → Std.DTreeMap.foldrM f init t₁ = Std.DTreeMap.foldrM f init t₂ | null | true |
Subsemiring.mk'._proof_4 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s : Set R) (sa : AddSubmonoid R), ↑sa = s → 0 ∈ s | null | false |
deriv_fun_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜},
DifferentiableAt 𝕜 f x → ∀ (n : ℕ), deriv (fun i => f i ^ n) x = ↑n * f x ^ (n - 1) * deriv f x | Eta-expanded form of `deriv_pow` | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.minFac_has_prop | Mathlib.Data.Nat.Prime.Defs | ∀ {n : ℕ}, n ≠ 1 → Nat.minFacProp✝ n n.minFac | null | true |
Int.Cooper.mul_resolve_left_inv_le | Init.Data.Int.Cooper | ∀ {b q : ℤ} (a p k : ℤ), 0 < a → b * k + b * p ≤ a * q → a ∣ k + p → b * Int.Cooper.resolve_left_inv a p k ≤ q | null | true |
CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj | Mathlib.CategoryTheory.Abelian.LeftDerived | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.Abelian C] →
[inst_3 : CategoryTheory.HasProjectiveResolutions C] →
[inst_4 : CategoryTheory.Abelian D] →
{X : C}... | If `P : ProjectiveResolution Z` and `F : C ⥤ D` is an additive functor, this is
an isomorphism between `F.leftDerivedToHomotopyCategory.obj X` and the complex
obtained by applying `F` to `P.complex`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.snd_ne_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, 3 ≤ p.length → 1 ≤ p.length | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_getKey?_eq_some_and_get?_eq_some._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Real.sigmoid_pos | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 < x.sigmoid | null | true |
_private.Mathlib.Order.Cover.0.Set.Ioo_eq_singleton_iff._to_dual_1.match_1_6 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α} (motive : c < a ∧ b < c → Prop) (x : c < a ∧ b < c),
(∀ (hac : c < a) (hcb : b < c), motive ⋯) → motive x | null | false |
monotoneOn_univ._simp_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β}, MonotoneOn f Set.univ = Monotone f | null | false |
_private.Init.Data.List.Nat.Sublist.0.List.append_sublist_of_sublist_right._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.length ≤ ys.length → xs.length + ys.length ≤ zs.length → ¬xs.length = 0 → False | null | false |
le_max_iff._simp_1 | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ max a b) = (c ≤ a ∨ c ≤ b) | null | false |
CategoryTheory.Arrow.LeftHomotopy.comp_hom | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] [inst_1 : CategoryTheory.Preadditive V]
{u v w : CategoryTheory.Arrow V} {f₁ g₁ : u ⟶ v} {f₂ g₂ : v ⟶ w} (h₁ : CategoryTheory.Arrow.LeftHomotopy f₁ g₁)
(h₂ : CategoryTheory.Arrow.LeftHomotopy f₂ g₂),
(h₁.comp h₂).hom =
CategoryTheory.CategoryStruc... | null | true |
CategoryTheory.Functor.IsDenseSubsite.sheafEquiv | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(G : CategoryTheory.Functor C D) →
(A : ... | If `G : C ⥤ D` exhibits `(C, J)` as a dense subsite of `(D, K)`, and the
pushforward functor `Sheaf K A ⥤ Sheaf J A` is an equivalence, then this
is the equivalence `Sheaf K A ≌ Sheaf J A`. | true |
Std.DHashMap.mem_toArray_iff_get?_eq_some | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, ⟨k, v⟩ ∈ m.toArray ↔ m.get? k = some v | null | true |
Module.AEval.restrict_equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), IsScalarTower R R ↥p | null | false |
Mathlib.Meta.NormNum.IsNNRat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionSemiring α] {n d : ℕ} {a n' d' : α},
Mathlib.Meta.NormNum.IsNNRat a n d → ↑n = n' → ↑d = d' → a = n' / d' | null | true |
Lean.Meta.Grind.instInhabitedEMatchTheoremConstraint | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheoremConstraint | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mk.sizeOf_spec | Mathlib.Tactic.Linter.FlexibleLinter | ∀ (stx : Lean.Syntax) (ci : Lean.Elab.ContextInfo) (mctxBefore mctxAfter : Lean.MetavarContext)
(goalsTargetedBy goalsCreatedBy : List Lean.MVarId),
sizeOf
{ stx := stx, ci := ci, mctxBefore := mctxBefore, mctxAfter := mctxAfter, goalsTargetedBy := goalsTargetedBy,
goalsCreatedBy := goalsCreatedBy } =... | null | true |
smul_add_smul_le_smul_add_smul | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
[inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_7 : Module α β]
[PosSMulMono α β] {a₁ a₂ : α} {b₁ b₂ : β}, a₁ ≤ a₂ → b₁ ≤ b₂ → a₁ • b₂ + a₂ • b₁ ≤ a₁ • b₁ +... | Binary **rearrangement inequality**. | true |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhss._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.MatchCond | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Quaternion.coe_real_complex_mul | Mathlib.Analysis.Quaternion | ∀ (r : ℝ) (z : ℂ), r • ↑z = ↑r * ↑z | null | true |
IsLocalization.instForallPiUniv | Mathlib.RingTheory.Localization.Pi | ∀ {ι : Type u_1} (R : ι → Type u_2) (S : ι → Type u_3) [inst : (i : ι) → CommSemiring (R i)]
[inst_1 : (i : ι) → CommSemiring (S i)] [inst_2 : (i : ι) → Algebra (R i) (S i)] (M : (i : ι) → Submonoid (R i))
[∀ (i : ι), IsLocalization (M i) (S i)], IsLocalization (Submonoid.pi Set.univ M) ((i : ι) → S i) | If `S i` is a localization of `R i` at the submonoid `M i` for each `i`,
then `Π i, S i` is a localization of `Π i, R i` at the product submonoid. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.