name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ConvexCone.mem_mk | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {s : Set M} {x : M} {h₁ : ∀ ⦃c : R⦄, 0 < c → ∀ ⦃x : M⦄, x ∈ s → c • x ∈ s}
{h₂ : ∀ ⦃x : M⦄, x ∈ s → ∀ ⦃y : M⦄, y ∈ s → x + y ∈ s}, x ∈ { carrier := s, smul_mem' := h₁, add_mem' := h₂ } ↔ x ∈ ... | null | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.FunBinders.elabFunBinderViews | Lean.Elab.Binders | Array Lean.Elab.Term.BinderView →
ℕ → Lean.Elab.Term.FunBinders.State → Lean.Elab.TermElabM Lean.Elab.Term.FunBinders.State | null | true |
Nat.one_lt_succ_succ | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 1 < n.succ.succ | null | true |
HasFDerivWithinAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{f' g' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → HasFDerivWithinAt g g' s ... | Eta-expanded form of `HasFDerivWithinAt.sub` | true |
Std.Http.Headers.get! | Std.Http.Data.Headers | Std.Http.Headers → Std.Http.Header.Name → Std.Http.Header.Value | Like `get?`, but panics if absent.
| true |
_private.Qq.Commands.0.Qq.mkLetFVarsFromValues | Qq.Commands | Array Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Build a let expression, similarly to `mkLetFVars`.
The array of `values` will be assigned to the current local context,
which is expected to consist of `cdecl`s.
| true |
Complex.isCauSeq_exp | Mathlib.Analysis.Complex.Exponential | ∀ (z : ℂ), IsCauSeq (fun x => ‖x‖) fun n => ∑ m ∈ Finset.range n, z ^ m / ↑m.factorial | null | true |
Filter.le_limsup_iff' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β}
[DenselyOrdered β] {x : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._auto_1 →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._au... | A version of `le_limsup_iff` with large inequalities in densely ordered spaces. | true |
List.monotone_sum_take | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] (L : List M),
Monotone fun i => (List.take i L).sum | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceOfNatAux._regBuiltin.Char.reduceOfNatAux.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.1314572429._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
AddMonoidAlgebra.smulZeroClass._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] {A : Type u_3} [inst_1 : SMulZeroClass A R] (a : A), a • 0 = 0 | null | false |
Lean.Meta.Sym.AlphaShareCommon.State.set._default | Lean.Meta.Sym.AlphaShareCommon | Lean.PHashSet Lean.Meta.Sym.AlphaKey | null | false |
CategoryTheory.Bicategory.Prod.snd_map₂ | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] {a b : B × C}
{f g : a ⟶ b} (a_1 : f ⟶ g), (CategoryTheory.Bicategory.Prod.snd B C).map₂ a_1 = a_1.2 | null | true |
MonadControl.noConfusionType | Init.Control.Basic | Sort u_1 →
{m : Type u → Type v} →
{n : Type u → Type w} →
MonadControl m n → {m' : Type u → Type v} → {n' : Type u → Type w} → MonadControl m' n' → Sort u_1 | null | false |
ContinuousMap.Homotopy.ulift_apply | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) (i : ULift.{u, 0} ↑unitInterval) (x : ↑X),
H.uliftMap (i, x) = H (i.down, x) | null | true |
_private.Lean.Elab.Do.Switch.0.Lean.Elab.Term.expandTermTry._regBuiltin.Lean.Elab.Term.expandTermTry.declRange_3 | Lean.Elab.Do.Switch | IO Unit | null | false |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.Birational.RationalMap | Lean.TrailingParserDescr | The notation for rational maps. | true |
Finsupp.coe_mk | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (f : α → M) (s : Finset α) (h : ∀ (a : α), a ∈ s ↔ f a ≠ 0),
⇑{ support := s, toFun := f, mem_support_toFun := h } = f | null | true |
UInt16.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | ∀ (n : UInt16), UInt16.ofNatClamp n.toNat = n | null | true |
Int.getElem_toList_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ} (_h : i < (m<...n).toList.length), (m<...n).toList[i] = m + 1 + ↑i | null | true |
_private.Mathlib.Tactic.GRewrite.Elab.0.Mathlib.Tactic.GRewrite.updateInfoTree.match_4 | Mathlib.Tactic.GRewrite.Elab | (motive : Lean.Elab.InfoTree → Sort u_1) →
(tree : Lean.Elab.InfoTree) →
((i : Lean.Elab.PartialContextInfo) → (tree : Lean.Elab.InfoTree) → motive (Lean.Elab.InfoTree.context i tree)) →
((i : Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) → motive (Lean.Elab.InfoTree.node ... | null | false |
_private.Mathlib.Data.PNat.Basic.0.PNat.dvd_iff._simp_1_1 | Mathlib.Data.PNat.Basic | ∀ (n : ℕ+), (↑n = 0) = False | null | false |
Rep.coinvariantsTensorIndInv._proof_2 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} [inst : CommRing k] {G H : Type u_1} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u_1, u_1, u_1} k G) (B : Rep.{u_1, u_1, u_1} k H),
SMulCommClass k k
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u_1, u_1, u_1} k H)).obj (Rep.ind φ A)).obj B).ρ.Coinvariants | null | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.mdifferentiableWithinAt_congr_set'._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra.0.CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.ext.match_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u_5} {inst : CategoryTheory.Category.{u_3, u_5} C}
{F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat)}
{ι : Type u_1} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentDataAsCoalgebra f}
(motive : D₁.Hom D₂ → ... | null | false |
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) →
(__discr : Option (Array Lean.Meta.CasesSubgoal)) →
((goals : Array Lean.Meta.CasesSubgoal) → motive (some goals)) →
((x : Option (Array Lean.Meta.CasesSubgoal)) → motive x) → motive __discr | null | false |
_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.InjectiveSeminorm | ∀ {ι : Type u_2} [inst : Fintype ι] {𝕜 : Type u_3} [inst_1 : NontriviallyNormedField 𝕜] {E : ι → Type u_1}
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [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)),
(∀ (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) | null | 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 |
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 (∀ (a : Matrix m n α), Matrix.addGroup._aux_2 0 a = 0) SubNegMonoid.zsmul_zero'._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 |
_private.Mathlib.RingTheory.MvPowerSeries.Trunc.0.MvPowerSeries.coeff_trunc'_mul_trunc'_eq_coeff_mul._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} [inst : DecidableEq σ] (n : σ →₀ ℕ) ⦃a b : σ →₀ ℕ⦄, b ≤ a → a ∈ ↑(Finset.Iic n) → b ∈ ↑(Finset.Iic n) | null | false |
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 |
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 |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_498 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.