name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Batteries.Data.Vector.Basic.0.Vector.USize.succ_toNat_of_lt._proof_1_2 | Batteries.Data.Vector.Basic | ∀ {start stop : USize} {n : ℕ},
stop.toNat ≤ n → n < 2 ^ 64 → start.toNat < stop.toNat → ¬(start.toNat + 1) % 2 ^ 64 = start.toNat + 1 → False | null | false |
UInt64.and_lt_add_one | Init.Data.UInt.Bitwise | ∀ {b c : UInt64}, c ≠ -1 → b &&& c < c + 1 | null | true |
SheafOfModules.QuasicoherentData.recOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddComm... | null | false |
Ordinal.invVeblen₂_le | Mathlib.SetTheory.Ordinal.Veblen | ∀ (x : Ordinal.{u_1}), x.invVeblen₂ ≤ x | null | true |
CategoryTheory.GrothendieckTopology.instPreorderCover._aux_1 | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
(J : CategoryTheory.GrothendieckTopology C) → (X : C) → J.Cover X → J.Cover X → Prop | null | false |
UpperHalfPlane.isOpenMap_re | Mathlib.Analysis.Complex.UpperHalfPlane.Topology | IsOpenMap UpperHalfPlane.re | null | true |
Nat.Internal.Linear.Expr.toPoly.go.eq_1 | Init.Data.Nat.Internal.Linear | ∀ (coeff k : ℕ),
Nat.Internal.Linear.Expr.toPoly.go coeff (Nat.Internal.Linear.Expr.num k) =
bif k == 0 then id else fun x => (coeff * k, Nat.Internal.Linear.fixedVar) :: x | null | true |
Lean.Elab.Command.AssertExists.noConfusionType | Lean.Elab.AssertExists | Sort u → Lean.Elab.Command.AssertExists → Lean.Elab.Command.AssertExists → Sort u | null | false |
AlgebraicGeometry.quasiSeparatedSpace_iff_quasiSeparated | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme),
QuasiSeparatedSpace ↥X ↔ AlgebraicGeometry.QuasiSeparated (CategoryTheory.Limits.terminal.from X) | null | true |
UInt32.pow._f | Init.Data.UInt.Basic | UInt32 → (n : ℕ) → Nat.below n → UInt32 | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff.0.Matrix.charpoly_monic._proof_1_2 | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {n : Type u_1} [inst : Fintype n], ¬Fintype.card n = 0 → Fintype.card n - 1 < Fintype.card n | null | false |
LieSubmodule.mem_bot | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), x ∈ ⊥ ↔ x = 0 | null | true |
SubMulAction.fg_iff | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | ∀ {R : Type u_1} {M : Type u_2} [inst : SMul R M] {p : SubMulAction R M}, p.FG ↔ ∃ s, p = SubMulAction.closure R ↑s | null | true |
WeierstrassCurve.c_relation_of_char_three | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [CharP R 3], W.c₄ ^ 3 = W.c₆ ^ 2 | null | true |
Polynomial.reverse_C_add | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(Polynomial.C t + p).reverse = Polynomial.C t * Polynomial.X ^ p.natDegree + p.reverse | null | true |
MulEquiv.symmEquiv_symm_apply_symm_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : Q ≃* P) (a : Q),
((MulEquiv.symmEquiv P Q).symm h).symm a = h a | null | true |
Std.HashMap.toList_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {c : ℕ}, (Std.HashMap.emptyWithCapacity c).toList = [] | null | true |
Units.inv_mul_le_one_of_le | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, a ≤ ↑u → ↑u⁻¹ * a ≤ 1 | **Alias** of the reverse direction of `Units.inv_mul_le_one`. | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.typeMatchesBaseName._unsafe_rec | Lean.Elab.App | Lean.Expr → Lean.Name → Lean.MetaM Bool | null | false |
perfectClosure.algEquivOfAlgEquiv._proof_3 | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E], IsScalarTower F F E | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.δ₀Iter_δ._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, n + i = m → n + i = m | null | false |
GaloisConnection.compl | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {l : α → β} {u : β → α},
GaloisConnection l u → GaloisConnection (compl ∘ u ∘ compl) (compl ∘ l ∘ compl) | null | true |
_private.Mathlib.Order.WithBot.0.WithTop.untop.match_1.splitter | Mathlib.Order.WithBot | {α : Type u_1} →
(motive : (x : WithTop α) → x ≠ ⊤ → Sort u_2) →
(x : WithTop α) → (x_1 : x ≠ ⊤) → ((x : α) → (x_2 : ↑x ≠ ⊤) → motive (some x) x_2) → motive x x_1 | null | true |
CategoryTheory.Limits.reflectsFiniteColimits_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.ReflectsFiniteLimits F.leftOp],
CategoryTheory.Limits.ReflectsFiniteColimits F | If `F.leftOp : Cᵒᵖ ⥤ D` reflects finite limits, then `F : C ⥤ Dᵒᵖ` reflects finite
colimits. | true |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.isOpen_forall_imp_mem._simp_1_3 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsOpen s = IsOpen (f ⁻¹' s) | null | false |
CategoryTheory.overEquivOfIsInitial._proof_5 | Mathlib.CategoryTheory.Comma.Over.StrictInitial | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasStrictInitialObjects C] (X : C) (h : CategoryTheory.Limits.IsInitial X)
(X_1 : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.star (CategoryTheory.Over X)).map
((Cat... | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_intMin_of_pos._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {v : ℕ}, ¬1 < 2 → False | null | false |
CategoryTheory.ShortComplex.instAbelian._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels (CategoryTheory.ShortComplex C) | null | false |
Std.TreeSet.Raw.maxD_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α}, (t.insert k).maxD fallback = t.max?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
Lean.Lsp.SignatureHelpParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams}
{toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams} {context? : Option Lean.Lsp.SignatureHelpContext}
{toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams}
{toWorkDoneProgressParams_1 : Lean.Lsp.WorkDoneProgressParams... | null | true |
_private.Lean.Expr.0.Lean.Expr.updateLet!Impl | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool → Lean.Expr | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.OwnReason.jpTailCallPreservation.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{jpFVar jpFVar' : Lean.FVarId} →
Lean.Compiler.LCNF.OwnReason.jpTailCallPreservation✝ jpFVar =
Lean.Compiler.LCNF.OwnReason.jpTailCallPreservation✝ jpFVar' →
(jpFVar = jpFVar' → P) → P | null | false |
_private.Mathlib.Tactic.CategoryTheory.ToApp.0.Mathlib.Tactic.CategoryTheory.ToApp.toCatExpr.match_1 | Mathlib.Tactic.CategoryTheory.ToApp | (motive : Lean.Name × Array Lean.Expr → Sort u_1) →
(x : Lean.Name × Array Lean.Expr) →
((head head_1 a head_2 : Lean.Expr) → motive (`Quiver.Hom, #[head, head_1, a, head_2])) →
((x : Lean.Name × Array Lean.Expr) → motive x) → motive x | null | false |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.mixfix._regBuiltin.Lean.Parser.Command.infixr.formatter_19 | Lean.Parser.Syntax | IO Unit | null | false |
MeasureTheory.NullMeasurableSet.right_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [hν : MeasureTheory.SFinite ν] {s : Set α} {t : Set β},
MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν) → μ s ≠ 0 → MeasureTheory.NullMeasurableSet t ν | If `s ×ˢ t` is a null measurable set and `μ s ≠ 0`, then `t` is a null measurable set. | true |
HomologicalComplex₂.ι_totalShift₁Iso_inv_f_assoc | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(a b n : ℤ) (h : a + b = n) (a' n' : ℤ) (ha' : a' + b = n') (hn' : n' = n + x) {Z : C}
(h_1 :... | null | true |
Subsemigroup.op_iInf | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {ι : Sort u_1} {M : Type u_2} [inst : Mul M] (S : ι → Subsemigroup M), (iInf S).op = ⨅ i, (S i).op | null | true |
Std.Tactic.BVDecide.Gate.casesOn | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | {motive : Std.Tactic.BVDecide.Gate → Sort u} →
(t : Std.Tactic.BVDecide.Gate) →
motive Std.Tactic.BVDecide.Gate.and →
motive Std.Tactic.BVDecide.Gate.xor →
motive Std.Tactic.BVDecide.Gate.beq → motive Std.Tactic.BVDecide.Gate.or → motive t | null | false |
JordanHolderLattice.second_iso | Mathlib.Order.JordanHolder | ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] {x y : X},
JordanHolderLattice.IsMaximal x (x ⊔ y) → JordanHolderLattice.Iso (x, x ⊔ y) (x ⊓ y, y) | null | true |
Plausible.PrintableProp.mk | Plausible.Testable | {p : Prop} → String → Plausible.PrintableProp p | null | true |
Std.Time.PlainDateTime.subMinutes | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Minute.Offset → Std.Time.PlainDateTime | Subtracts a `Minute.Offset` from a `PlainDateTime`, adjusting the hour and date if the minutes underflow.
| true |
Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx.jpScopes._default | Lean.Compiler.LCNF.JoinPoints | Lean.FVarIdMap Lean.FVarIdSet | null | false |
Path.continuous_trans | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X}, Continuous fun ρ => ρ.1.trans ρ.2 | null | true |
Nat.Partition.ofSymShapeEquiv | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} →
{σ : Type u_1} →
{τ : Type u_2} →
[inst : DecidableEq σ] →
[inst_1 : DecidableEq τ] →
(μ : n.Partition) → σ ≃ τ → { x // Nat.Partition.ofSym x = μ } ≃ { x // Nat.Partition.ofSym x = μ } | An equivalence between `σ` and `τ` induces an equivalence between the subtypes of `Sym σ n` and
`Sym τ n` corresponding to a given partition. | true |
CategoryTheory.Functor.mapConeWhisker | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{D : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] →
... | `mapCone` commutes with `whisker` | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_ric_eq_singleton_iff._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k n : ℕ}, ¬(0 = k ∧ n = 0 ↔ n = 0 ∧ 0 = k) → False | null | false |
_private.Mathlib.Geometry.Manifold.Diffeomorph.0.Diffeomorph.uniqueDiffOn_image._simp_1_1 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E}, UniqueDiffOn 𝕜 s = UniqueMDiff[s] | null | false |
_private.Std.Data.String.ToNat.0.String.isSome_toNat?._simp_1_2 | Std.Data.String.ToNat | ∀ {s : String}, s.toNat? = s.toSlice.toNat? | null | false |
MulEquiv.subsemigroupMap._proof_2 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N) (S : Subsemigroup M) (x : ↥S),
↑e ↑x ∈ ⇑↑e '' ↑S | null | false |
WeierstrassCurve.Affine.Point.some.injEq | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} (x y : R) (h : W'.Nonsingular x y) (x_1 y_1 : R)
(h_1 : W'.Nonsingular x_1 y_1),
(WeierstrassCurve.Affine.Point.some x y h = WeierstrassCurve.Affine.Point.some x_1 y_1 h_1) = (x = x_1 ∧ y = y_1) | null | true |
Asymptotics.isBigO_iff_eventually_isBigOWith | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_3} {F' : Type u_7} [inst : Norm E] [inst_1 : SeminormedAddCommGroup F'] {f : α → E}
{g' : α → F'} {l : Filter α}, f =O[l] g' ↔ ∀ᶠ (c : ℝ) in Filter.atTop, Asymptotics.IsBigOWith c l f g' | `f = O(g)` if and only if `IsBigOWith c f g` for all sufficiently large `c`. | true |
Complex.deriv_log_comp_eq_logDeriv | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {x : ℂ}, DifferentiableAt ℂ f x → f x ∈ Complex.slitPlane → deriv (Complex.log ∘ f) x = logDeriv f x | The derivative of `log ∘ f` is the logarithmic derivative provided `f` is differentiable and
we are on the slitPlane. | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mul.match_1 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.qNF q(«$M») → Mathlib.Tactic.FieldSimp.qNF q(«$M») → Sort u_1) →
(x x_1 : Mathlib.Tactic.FieldSimp.qNF q(«$M»)) →
((l : Mathlib.Tactic.FieldSimp.qNF q(«$M»)) → motive [] l) →
((l : Mathlib.Tactic.FieldSimp.qNF q(«$M»))... | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable.casesOn | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {b : ByteArray} →
{v : Array ℕ} →
{motive : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝ b v → Sort u} →
(t : String.Slice.Pattern.Model.ForwardSliceSearcher.IsTable✝ b v) →
((size_le : v.size ≤ b.size) →
(eq_prefixFunction :
∀ (i : ℕ) (hi : i < v.size),
... | null | false |
Int8.toBitVec_max | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a ⊔ b).toBitVec = if a.toBitVec.sle b.toBitVec = true then b.toBitVec else a.toBitVec | null | true |
CategoryTheory.Mon.Hom.rec | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.Mon C} →
{motive : M.Hom N → Sort u} →
((hom : M.X ⟶ N.X) →
[isMonHom_hom : CategoryTheory.IsMonHom hom] → motive { hom := hom, isMonHom_hom := i... | null | false |
Equiv.sumCompl_symm_apply_of_pos | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_9} {p : α → Prop} [inst : DecidablePred p] {a : α} (h : p a), (Equiv.sumCompl p).symm a = Sum.inl ⟨a, h⟩ | null | true |
TopologicalSpace.Opens.toTopCat._proof_1 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat) (X_1 : TopologicalSpace.Opens ↑X),
TopCat.ofHom { toFun := fun x => ⟨↑x, ⋯⟩, continuous_toFun := ⋯ } = CategoryTheory.CategoryStruct.id ↧↥X_1 | null | false |
_private.Lean.Meta.WHNF.0.Lean.Meta.mkProjFn.match_1 | Lean.Meta.WHNF | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → (Unit → motive none) → ((projFn : Lean.Name) → motive (some projFn)) → motive x | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceIsDigit.declare_56._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.3934525011._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
intervalIntegral.integral_comp_mul_deriv_of_deriv_nonpos | Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts | ∀ {a b : ℝ} {f f' g : ℝ → ℝ},
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt f (f' x) x) →
(∀ x ∈ Set.Ioo (min a b) (max a b), f' x ≤ 0) → ∫ (x : ℝ) in a..b, (g ∘ f) x * f' x = ∫ (u : ℝ) in f a..f b, g u | Change of variables for monotone functions.
If `f` is continuous on `[a, b]` and has a nonnegative derivative `f'` in `(a, b)`,
then we can substitute `u = f x` to get `∫ x in a..b, (g ∘ f) x * f' x = ∫ u in f a..f b, g u`. | true |
RootPairing.Equiv.toEndUnit._proof_7 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (f : P.Aut),
(fun f =>
let __src := ↑f;
{ toHom := __src, bijective_weightMap := ⋯, bijective_co... | null | false |
CategoryTheory.Functor.pushforwardContinuousSheafificationCompatibility | Mathlib.CategoryTheory.Sites.CoverLifting | {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] →
(G : CategoryTheory.Functor C D) →
(A : Type w) →
[inst_2 : CategoryTheory.Category.{w', w} A] →
(J : CategoryTheory.GrothendieckTop... | The natural isomorphism exhibiting compatibility between pushforward and sheafification. | true |
MulOpposite.opAddEquiv_toEquiv | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {α : Type u_2} [inst : Add α], ↑MulOpposite.opAddEquiv = MulOpposite.opEquiv | null | true |
PSet.ctorIdx | Mathlib.SetTheory.ZFC.PSet | PSet.{u} → ℕ | null | false |
HasGradientAtFilter.isBigO_sub | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {f' x : F} {L : Filter F},
HasGradientAtFilter f f' x L → (fun x' => f x' - f x) =O[L] fun x' => x' - x | null | true |
String.Slice.Pattern.Char.instBackwardPatternChar | Init.Data.String.Pattern.Char | {c : Char} → String.Slice.Pattern.BackwardPattern c | null | true |
Metric.closedEBall_zero | Mathlib.Topology.EMetricSpace.Defs | ∀ {γ : Type w} [inst : TopologicalSpace γ] [inst_1 : WeakEMetricSpace γ] (x : γ), Metric.closedEBall x 0 = {x} | null | true |
Ordinal.mod_zero | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a : Ordinal.{u_4}), a % 0 = a | null | true |
Topology.IsQuotientMap.trivializationOfVAddDisjoint | Mathlib.Topology.Covering.Quotient | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{f : E → X} →
{G : Type u_3} →
[inst_2 : AddGroup G] →
[inst_3 : AddAction G E] →
[ContinuousConstVAdd G E] →
Topology.IsQuotientMap f... | If a group `G` acts on a space `E` and `U` is an open subset disjoint from all
other `G`-translates of itself, and `p` is a quotient map by this action, then `p` admits a
`Bundle.Trivialization` over the base set `p(U)`. | true |
ZLattice.module_finite | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [HasSolidNorm K] [FloorRing K]
{E : Type u_2} [inst_5 : NormedAddCommGroup E] [inst_6 : NormedSpace K E] [FiniteDimensional K E] [ProperSpace E]
(L : Submodule ℤ E) [inst_9 : DiscreteTopology ↥L] [IsZLattice K L], Module.Finite... | null | true |
SimpleGraph.Walk.mem_darts_iff_infix_support | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u v u' v' : V} {p : G.Walk u v} (h : G.Adj u' v'),
{ fst := u', snd := v', adj := h } ∈ p.darts ↔ [u', v'] <:+: p.support | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.Reason._sizeOf_1 | Std.Time.Format.Basic | Std.Time.Reason✝ → ℕ | null | false |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.mkJpAlt.go | Lean.Compiler.LCNF.Simp.JpCases | Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
ℕ →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Bool →
Lean.Comp... | null | true |
ContDiffAt.const_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{R : Type u_3} [inst_5 : DistribSMul R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F] {f : E... | The scalar multiplication of a constant and a `C^n` function at a point is `C^n` at this
point. | true |
Set.Iio_succ_eq_Iic | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (a : α),
Set.Iio (Order.succ a) = Set.Iic a | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Mathlib.RingTheory.PowerSeries.WellKnown.0.PowerSeries.map_invUnitsSub._simp_1_1 | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
Lean.Elab.Do.MonadInfo.u | Lean.Elab.Do.Basic | Lean.Elab.Do.MonadInfo → Lean.Level | The `u` in `m : Type u → Type v`. | true |
CategoryTheory.ExactFunctor.whiskeringRight._proof_4 | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (E : Type u_6) [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
{F G : D ⥤ₑ E} (η : F ⟶ G) ⦃X Y : C ⥤ₑ D⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.exactFuncto... | null | false |
Lean.TraceState.ctorIdx | Lean.Util.Trace | Lean.TraceState → ℕ | null | false |
AlgHom.IsArithFrobAt.restrict.congr_simp | Mathlib.RingTheory.Frobenius | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {φ φ_1 : S →ₐ[R] S}
(e_φ : φ = φ_1) {Q : Ideal S} (H : φ.IsArithFrobAt Q), H.restrict = ⋯.restrict | null | true |
Option.instLawfulIdentityMaxNone | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Max α], Std.LawfulIdentity max none | null | true |
SupHom.instSemilatticeSup._proof_2 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : SemilatticeSup β] {x y : SupHom α β}, ⇑x ≤ ⇑y ↔ ⇑x ≤ ⇑y | null | false |
TestFunction.mkCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} {V : Type u_3} [inst_6 : AddCommGroup V]
[in... | null | false |
Subfield.extendScalars.orderIso_symm_apply | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L) (E : IntermediateField (↥F) L),
(RelIso.symm (Subfield.extendScalars.orderIso F)) E = ⟨E.toSubfield, ⋯⟩ | null | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheorem?.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
((result : Lean.Meta.Simp.Result) → motive (some result)) → (Unit → motive none) → motive __do_lift | null | false |
Nat.instNonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Nat | ∀ (a : ℕ), 1 * a = a | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux_append_extractLsb'._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {len : ℕ} {w : ℕ}, ¬len - 1 ≤ len - 1 → False | null | false |
Std.Do.SPred.entails_3 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
P ⊢ₛ Q ↔ ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down | null | true |
Aesop.Frontend.Parser.declareRuleSets | Aesop.Frontend.Command | Lean.ParserDescr | null | true |
TopologicalSpace.Clopens.instHImp._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s t : TopologicalSpace.Clopens α), IsClopen (↑s ⇨ ↑t) | null | false |
CategoryTheory.Limits.binaryBiconeOfIsSplitMonoOfCokernel._proof_2 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{f : X ⟶ Y} [inst_2 : CategoryTheory.IsSplitMono f],
CategoryTheory.CategoryStruct.id Y -
(CategoryTheory.CategoryStruct.id Y - CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f) =... | null | false |
Lean.Elab.Term.Quotation.IdxSet | Lean.Elab.Quotation | Type | null | true |
ZMod.trace_pow_card | Mathlib.LinearAlgebra.Matrix.Charpoly.FiniteField | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {p : ℕ} [inst_2 : Fact (Nat.Prime p)]
(M : Matrix n n (ZMod p)), (M ^ p).trace = M.trace ^ p | null | true |
CategoryTheory.CatCommSq.vInv_vInv | Mathlib.CategoryTheory.CatCommSq | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄] (T : CategoryTheory.Functor C₁ C₂) (L : C₁ ≌ C₃) (R : C₂... | null | true |
tendsto_setIntegral_pow_smul_of_unique_maximum_of_isCompact_of_integrableOn | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u_1} {E : Type u_2} {hm : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace α]
[BorelSpace α] [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E] {g : α → E} {x₀ : α} {s : Set α}
[CompleteSpace E] [TopologicalSpace.MetrizableSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ... | If a continuous function `c` realizes its maximum at a unique point `x₀` in a compact set `s`,
then the sequence of functions `(c x) ^ n / ∫ (c x) ^ n` is a sequence of peak functions
concentrating around `x₀`. Therefore, `∫ (c x) ^ n * g / ∫ (c x) ^ n` converges to `g x₀` if `g` is
integrable on `s` and continuous at ... | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.reduceQuotRec.match_8 | Lean.Meta.WHNF | (motive : Lean.QuotKind → Sort u_1) →
(x : Lean.QuotKind) →
(Unit → motive Lean.QuotKind.lift) → (Unit → motive Lean.QuotKind.ind) → ((x : Lean.QuotKind) → motive x) → motive x | null | false |
SimplexCategory.coe_δ | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (i : Fin (n + 2)), ⇑(CategoryTheory.ConcreteCategory.hom (SimplexCategory.δ i)) = i.succAbove | null | true |
LinearMap.IsPerfectCompl.recOn | Mathlib.LinearAlgebra.PerfectPairing.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] →
{p : M →ₗ[R] N →ₗ[R] R} →
[inst_5 : p.IsPerfPai... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.