name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsLocalDiffeomorphAt.localInverse_contMDiffOn | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : 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] {H₁ : Type u_5}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | null | true |
fderivWithin_continuousAlternatingMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousAlternatingMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G]
[inst... | null | true |
Filter.tendsto_principal_principal | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β},
Filter.Tendsto f (Filter.principal s) (Filter.principal t) ↔ ∀ a ∈ s, f a ∈ t | null | true |
PointedCone.coe_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] (K : PointedCone 𝕜 E), ↑K.closure = closure ↑K | null | true |
Std.TreeSet.casesOn | Std.Data.TreeSet.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.TreeSet α cmp → Sort u_1} →
(t : Std.TreeSet α cmp) → ((inner : Std.TreeMap α Unit cmp) → motive { inner := inner }) → motive t | null | false |
Set.vsub_iUnion | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} [inst : VSub α β] (s : Set β) (t : ι → Set β),
s -ᵥ ⋃ i, t i = ⋃ i, s -ᵥ t i | null | true |
WithTop.forall_ne_top | Mathlib.Order.WithBot | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), x ≠ ⊤ → p x) ↔ ∀ (x : α), p ↑x | null | true |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticAdmit_1 | Init.Tactics | Lean.Macro | `admit` is a synonym for `sorry`. | false |
CategoryTheory.Limits.coneOfConeCurry_pt | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) {D : CategoryTheory.Limits.DiagramOfCones (CategoryTheory.Functor.curry.obj G)}
(Q : (... | null | true |
CategoryTheory.MonoidalPreadditive.instAdditiveFunctorFlipCurriedTensor | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C],
(CategoryTheory.MonoidalCategory.curriedTensor C).flip.Additive | null | true |
ExistsContDiffBumpBase.y_eq_one_of_mem_closedBall | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] {D : ℝ} {x : E},
0 < D → x ∈ Metric.closedBall 0 (1 - D) → ExistsContDiffBumpBase.y D x = 1 | null | true |
ModuleCat.ExtendRestrictScalarsAdj.Counit.map._proof_3 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {Y : ModuleCat S} (r : R)
(s : S),
{ toFun := fun y => (r • s) • y, map_add' := ⋯, map_smul' := ⋯ } =
(RingHom.id R) r • { toFun := fun y => s • y, map_add' := ⋯, map_smul' := ⋯ } | null | false |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_2 | Mathlib.RingTheory.Support | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
NonUnitalStarAlgebra.adjoin_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (s : Set A),
(NonUnitalStarAlgebra.adjoin R s).toNonUnitalSubalgebra = NonUni... | null | true |
Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α], Std.Associative max | null | true |
CategoryTheory.endofunctorMonoidalCategory_whiskerLeft_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {F H K : CategoryTheory.Functor C C} {β : H ⟶ K} (X : C),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft F β).app X = β.app (F.obj X) | null | true |
Set.Ico_diff_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a b \ Set.Iio c = Set.Ico (max a c) b | **Alias** of `Set.Ico_sdiff_Iio`. | true |
CategoryTheory.IsAddMonHom.Normal.exists_comp_eq_addConj | Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.CartesianMonoidalCategory C}
{G H : C} {inst_2 : CategoryTheory.AddGrpObj G} {inst_3 : CategoryTheory.AddGrpObj H} {φ : H ⟶ G}
[self : CategoryTheory.IsAddMonHom.Normal φ],
∃ ψ,
CategoryTheory.CategoryStruct.comp ψ φ =
... | null | true |
Left.self_le_neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] {a : α}, a ≤ 0 → a ≤ -a | null | true |
_private.Init.Data.Array.Find.0.Array.getElem_zero_flatten.proof._simp_1_2 | Init.Data.Array.Find | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [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} {i j : ι} [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M], P.IsOrthogonal i j = (P.pairing i j = 0) | null | false |
meromorphicAt_of_meromorphicOrderAt_ne_zero | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x ≠ 0 → MeromorphicAt f x | null | true |
TopologicalSpace.Compacts.mem_singleton | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x y : α), x ∈ {y} ↔ x = y | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_B._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
(∀ i ∈ s, IsOpen (f i)) → IsOpen (⋃ i ∈ s, f i) = True | null | false |
FractionalIdeal.coeIdeal | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_1} →
[inst : CommRing R] →
{S : Submonoid R} → {P : Type u_2} → [inst_1 : CommRing P] → [inst_2 : Algebra R P] → Ideal R → FractionalIdeal S P | Map an ideal `I` to a fractional ideal by forgetting `I` is integral.
This is the function that implements the coercion `Ideal R → FractionalIdeal S P`. | true |
Nat.le_of_ble_eq_true | Init.Prelude | ∀ {n m : ℕ}, n.ble m = true → n ≤ m | null | true |
hasProd_prod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} [ContinuousMul α] {f : γ → β → α} {a : γ → α} {s : Finset γ},
(∀ i ∈ s, HasProd (f i) (a i) L) → HasProd (fun b => ∏ i ∈ s, f i b) (∏ i ∈ s, a i) L | null | true |
ProbabilityTheory.Kernel.sectR._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_2} {β : Type u_1} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (a : α),
Measurable fun a_1 => (a, a_1) | null | false |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}) (motive : { x // x ∈ Set.Iio o } → Sort u_2) (x : Ordinal.{u_1}) (property : x ∈ Set.Iio o)
(h_1 : (x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩),
(match ⟨x, property⟩ with
| ⟨x, property⟩ => h_1 x property) =
h_1 x property | null | true |
CategoryTheory.WithTerminal.equivComma_functor_map_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{X Y : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D} (η : X ⟶ Y) (X_1 : C),
(CategoryTheory.WithTerminal.equivComma.functor.map η).left.app X_1 = η.app (CategoryTheory.WithTerminal.inc... | null | true |
Nat.Coprime.mul_gcd | Init.Data.Nat.Coprime | ∀ {m n : ℕ}, m.Coprime n → ∀ (k : ℕ), (m * n).gcd k = m.gcd k * n.gcd k | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.isLongestRevMatch_cast_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
CategoryTheory.MorphismProperty.RespectsLeft.rec | Mathlib.CategoryTheory.MorphismProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.RespectsLeft Q → Sort u_1} →
((precomp : ∀ {X Y Z : C} (i : X ⟶ Y), Q i → ∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
motive ⋯) →
(t :... | null | false |
SimpleGraph.EdgeLabeling.compRight_get | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {K' : Type u_4} {C : G.EdgeLabeling K} (f : K → K') (x y : V)
(h : G.Adj x y), (C.compRight f).get x y h = f (C.get x y h) | null | true |
BoolRing.instCategory._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := { hom' := RingHom.id ↑Y }.hom'.comp f.hom' } = f | null | false |
IsDivApply.mk | Mathlib.Data.FunLike.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} [inst : FunLike F α β] [inst_1 : Div β]
[inst_2 : Div F], (∀ (f g : F) (x : α), (f / g) x = f x / g x) → IsDivApply F α β | null | true |
CochainComplex.singleFunctors.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C],
CochainComplex.singleFunctors C =
{ functor := fun n => HomologicalComplex.single C (ComplexShape.up ℤ) n,
shiftIso := fun n a a' ha' =>
CategoryTheory... | null | true |
TopologicalSpace.Clopens.exists_finset_eq_sup_prod | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
[CompactSpace X] (W : TopologicalSpace.Clopens (X × Y)), ∃ I, W = I.sup fun i => i.1 ×ˢ i.2 | Every clopen set in a product of two compact spaces
is a union of finitely many clopen boxes. | true |
Subalgebra.mulMap_comm | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
(A B : Subalgebra R S), B.mulMap A = (A.mulMap B).comp ↑(Algebra.TensorProduct.comm R ↥B ↥A) | null | true |
instSliceableByteArrayNatByteSlice_3 | Std.Data.ByteSlice | Std.Roc.Sliceable ByteArray ℕ ByteSlice | null | true |
SSet.stdSimplex.faceRepresentableBy._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory} (f : j ⟶ { len := m }),
∀
x ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((OrderHom.Subtype.val fun x => x ∈ S).com... | null | false |
Std.DHashMap.Raw.get?_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → (m₁ ∩ m₂).get? k = m₁.get? k | null | true |
IsAddLeftRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsLeftCancelAdd R] (g : R), IsAddLeftRegular g | If all additions cancel on the left then every element is add-left-regular. | true |
stdSimplex.instUniqueElemForall._proof_1 | Mathlib.Analysis.Convex.StdSimplex | ∀ {S : Type u_1} [inst : Semiring S] [inst_1 : PartialOrder S] {X : Type u_2} [IsOrderedRing S] (x : X), 0 ≤ 1 x | null | false |
Lean.Meta.Grind.CanonArgKey.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (f : Lean.Expr) (i : ℕ) (arg f_1 : Lean.Expr) (i_1 : ℕ) (arg_1 : Lean.Expr),
({ f := f, i := i, arg := arg } = { f := f_1, i := i_1, arg := arg_1 }) = (f = f_1 ∧ i = i_1 ∧ arg = arg_1) | null | true |
Matrix.isUnit_conjTranspose._simp_1 | Mathlib.LinearAlgebra.Matrix.Invertible | ∀ {n : Type u_2} {α : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring α] [inst_3 : StarRing α]
(A : Matrix n n α), IsUnit A.conjTranspose = IsUnit A | null | false |
DirectLimit.Ring.of_apply | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
(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 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.BaseChange.0.Algebra.tensorH1CotangentOfFlat._proof_7 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T],
LinearMap.CompatibleSMul (Algebra.Generators.self R S).toExtension.baseChange.H1Cotangent
(Algebra.Generators.baseChange T (Algebra.Generators.self R S)).... | null | false |
WeierstrassCurve.Jacobian.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) | null | true |
AddMonoidAlgebra.mapAlgEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_4) {A : Type u_1} {B : Type u_3} (M : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddMonoid M] (e : A ≃ₐ[R] B)
(x y : AddMonoidAlgebra A M),
(↑↑(AddMonoidAlgebra.mapAlgHom M ↑e).toRingHom).toFun (x + y) =
(... | null | false |
Int.fdiv_eq_ediv_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → a.fdiv b = a / b | null | true |
Std.DTreeMap.Internal.Impl.minKey!_erase_eq_of_not_compare_minKey!_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α] (h : t.WF) {k : α},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty = false →
¬compare k t.minKey! = Ordering.eq → (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey! = t.minKey! | null | true |
UInt8.toUInt64_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a ^^^ b).toUInt64 = a.toUInt64 ^^^ b.toUInt64 | null | true |
AddMonoidAlgebra.semiring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] (x : AddMonoidAlgebra R M),
npowRecAuto 0 x = 1 | null | false |
Fin.encodeSigma._unsafe_rec | Batteries.Data.Fin.Coding | {n : ℕ} → (f : Fin n → ℕ) → (i : Fin n) × Fin (f i) → Fin (Fin.sum f) | null | false |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.initFn._@.Lean.PrettyPrinter.4173001584._hygCtx._hyg.2 | Lean.PrettyPrinter | IO Unit | null | false |
Lean.findField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name | Returns the name of the structure that contains the field relative to structure `structName`.
If `structName` contains the field itself, returns that,
and otherwise recursively looks into parents that are subobjects.
| true |
_private.Init.Grind.Ordered.Int.0.Lean.Grind.instOrderedRingInt._proof_1 | Init.Grind.Ordered.Int | ¬0 < 1 → False | null | false |
Std.DTreeMap.Internal.Impl.size_balanceR | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β} (hlb : l.Balanced)
(hrb : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size l.size),
(Std.DTreeMap.Internal.Impl.balanceR k v l r hlb hrb hlr).size = l.size + 1 + r.size | null | true |
LinearIndepOn.notMem_span_iff | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{s : Set ι} {a : ι} {f : ι → V},
LinearIndepOn K f s → (f a ∉ Submodule.span K (f '' s) ↔ LinearIndepOn K f (insert a s) ∧ a ∉ s) | A shortcut to a convenient form for the negation in `LinearIndepOn.mem_span_iff`. | true |
AList.toFinmap_entries | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (s : AList β), s.toFinmap.entries = ↑s.entries | null | true |
SpectralMap.coe_id | Mathlib.Topology.Spectral.Hom | ∀ (α : Type u_2) [inst : TopologicalSpace α], ⇑(SpectralMap.id α) = id | null | true |
Matrix.toEuclideanLin_apply_piLp_toLp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : Type u_7} {n : Type u_8} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n 𝕜) (v : n → 𝕜), (Matrix.toEuclideanLin M) (WithLp.toLp 2 v) = WithLp.toLp 2 (M.mulVec v) | null | true |
AddCon.coe_inf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, ⇑c ⊓ ⇑d = ⇑(c ⊓ d) | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ) (hr : r₀ ≤ r),
(c r).Rel pq pq' → data.i₀ r pq ⋯ = data.i₂ pq' | null | false |
DifferentiableOn.isConservativeOn | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {U : Set ℂ},
DifferentiableOn ℂ f U → Complex.IsConservativeOn f U | null | true |
_private.Mathlib.Analysis.Asymptotics.TVS.0.Asymptotics.isLittleOTVS_iff_isLittleO._simp_1_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | null | false |
Nat.add_sub_add_right | Init.Data.Nat.Basic | ∀ (n k m : ℕ), n + k - (m + k) = n - m | null | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRevM.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRevM f init b =
Array.foldrM (fun l acc => Std.DHashMap.Internal.AssocList.foldrM (fun a b d => f d a b) acc l) init b.buckets | null | true |
CategoryTheory.Triangulated.AbelianSubcategory.isLimitKernelFork._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_4} {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | null | false |
CategoryTheory.Iso.inv_hom_id_app_apply | Mathlib.CategoryTheory.Types.Basic | ∀ {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} (α : F ≅ G) (X : C) {F_1 : D → D → Type uF} {carrier : D → Type w}
{instFunLike : (X Y : D) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : CategoryTheory... | null | true |
Std.Iterators.Types.DropWhile.dropping | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} → Std.Iterators.Types.DropWhile α m β P → Bool | Internal implementation detail of the iterator library. | true |
Lean.Meta.Grind.GoalState.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{nextDeclIdx : ℕ} →
{enodeMap : Lean.Meta.Grind.ENodeMap} →
{exprs : Lean.PArray Lean.Expr} →
{parents : Lean.Meta.Grind.ParentMap} →
{congrTable : Lean.Meta.Grind.CongrTable enodeMap} →
{appMap : Lean.PHashMap Lean.HeadIndex (List Lean.Expr)} →
{in... | null | false |
continuousMultilinearCurryFin0._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G : Type u_2) (G' : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] (x x_1 : G [×0]→L[𝕜] G'),
(x + x_1).curry0 = (x + x_1).curry0 | null | false |
EuclideanSpace.inner_single_right | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜)
(v : EuclideanSpace 𝕜 ι), inner 𝕜 v (EuclideanSpace.single i a) = a * (starRingEnd ((fun x => 𝕜) i)) (v.ofLp i) | null | true |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_empty._proof_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {p : ↑unitInterval} (s : Set (Set ι)), ∅ ∉ s → {t | t ∈ s ∧ t ⊆ ∅} = ∅ | null | false |
_private.Mathlib.Data.ENNReal.Inv.0.ENNReal.exists_mem_Ico_zpow._simp_1_1 | Mathlib.Data.ENNReal.Inv | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | null | false |
Aesop.RuleStats.mk._flat_ctor | Aesop.Stats.Basic | Aesop.DisplayRuleName → Aesop.Nanos → Bool → Aesop.RuleStats | null | false |
WithZero.instRepr | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → [Repr α] → Repr (WithZero α) | null | true |
Aesop.GoalData.ctorIdx | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → ℕ | null | false |
CategoryTheory.MorphismProperty.Comma.mapRightIso_inverse_map_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
_private.Mathlib.Algebra.Order.Ring.Int.0.Nat.exists_add_mul_eq_of_gcd_dvd_of_mul_pred_le.match_1_1 | Mathlib.Algebra.Order.Ring.Int | ∀ (q n : ℕ) (motive : q ∣ n → Prop) (x : q ∣ n), (∀ (b : ℕ) (eq : n = q * b), motive ⋯) → motive x | null | false |
_private.Init.Internal.Order.Lemmas.0.Array.mapM.map.eq_def | Init.Internal.Order.Lemmas | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ) (bs : Array β),
Array.mapM.map✝ f as i bs =
if hlt : i < as.size then do
let __do_lift ← f as[i]
Array.mapM.map✝ f as (i + 1) (bs.push __do_lift)
else pure bs | null | true |
ModularForm.cuspFormSubmodule.eq_1 | Mathlib.NumberTheory.ModularForms.CuspFormSubmodule | ∀ (Γ : Subgroup (GL (Fin 2) ℝ)) (k : ℤ) [inst : Γ.HasDetOne],
ModularForm.cuspFormSubmodule Γ k = CuspForm.toModularFormₗ.range | null | true |
Lean.PersistentArrayNode.brecOn.eq | Lean.Data.PersistentArray | ∀ {α : Type u} {motive_1 : Lean.PersistentArrayNode α → Sort u_1}
{motive_2 : Array (Lean.PersistentArrayNode α) → Sort u_1} {motive_3 : List (Lean.PersistentArrayNode α) → Sort u_1}
(t : Lean.PersistentArrayNode α) (F_1 : (t : Lean.PersistentArrayNode α) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Persistent... | null | true |
ContinuousLinearMap.bilinearRestrictScalars_eq_restrictScalars_restrictScalarsL_comp | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_6} {G : Type u_8} {𝕜' : Type u_11} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E]
... | null | true |
Module.Basis.ofIsLocalizedModule_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [inst_3 : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[i... | null | true |
Nat.dist_tri_right' | Mathlib.Data.Nat.Dist | ∀ (n m : ℕ), n ≤ m + n.dist m | null | true |
ClusterPt.mono | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {f g : Filter X}, ClusterPt x f → f ≤ g → ClusterPt x g | null | true |
TopCat.pathEquiv_symm_apply_hom_hom_apply | Mathlib.Topology.Homotopy.TopCat.Path | ∀ {X : TopCat} {x y : ↑X} (p : Path x y) (a : ULift.{u, 0} ↑unitInterval),
(TopCat.Hom.hom (TopCat.pathEquiv.symm p).hom) a = p (TopCat.I.homeomorph a) | null | true |
Lean.PersistentHashMap.mapMAux | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type u} →
{m : Type u → Type w} →
[Monad m] → (β → m σ) → Lean.PersistentHashMap.Node α β → m (Lean.PersistentHashMap.Node α σ) | null | true |
CategoryTheory.Presieve.HasPairwisePullbacks.casesOn | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{R : CategoryTheory.Presieve X} →
{motive : R.HasPairwisePullbacks → Sort u} →
(t : R.HasPairwisePullbacks) →
((has_pullbacks :
∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → Category... | null | false |
CategoryTheory.Comma.equivProd_functor_obj | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (a : CategoryTheory.Comma L R),
(CategoryTheory.... | null | true |
Std.TreeMap.getKey_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Inhabited α] {k : α}
{f : Option β → Option β} {hc : k ∈ t.alter k f}, (t.alter k f).getKey k hc = k | null | true |
DFinsupp.erase_single | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (j i : ι) (x : β i),
(DFinsupp.erase j fun₀ | i => x) = if i = j then 0 else fun₀ | i => x | null | true |
CategoryTheory.Center.ofBraided | Mathlib.CategoryTheory.Monoidal.Center | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.Functor C (CategoryTheory.Center C) | The functor lifting a braided category to its center, using the braiding as the half-braiding.
| true |
Std.Format.FlattenAllowability.allow.elim | Init.Data.Format.Basic | {motive : Std.Format.FlattenAllowability → Sort u} →
(t : Std.Format.FlattenAllowability) →
t.ctorIdx = 0 → ((fits : Bool) → motive (Std.Format.FlattenAllowability.allow fits)) → motive t | null | false |
CategoryTheory.MonoidalCategory.rightUnitor_tensor_inv | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLe... | null | true |
Array.scanrM.loop._unary | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → β → m β) → (as : Array α) → ℕ → (_ : β) ×' (start : ℕ) ×' (_ : start ≤ as.size) ×' Array β → m (Array β) | auxiliary tail-recursive function for scanrM | false |
Subsemigroup.coe_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup N) (f : M →ₙ* N),
↑(Subsemigroup.comap f S) = ⇑f ⁻¹' ↑S | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.