name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1.else_eq | Lean.Elab.Tactic.Try | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1✝ t some «else» = «else» h | null | false |
Filter.prod_map_map_eq' | Mathlib.Order.Filter.Prod | ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁)
(G : Filter β₁), Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G) | null | true |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_4 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊥) = (x = 0) | null | false |
Submonoid.mk_inv_mul_mk_eq_one | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units),
⟨(Units.coeHom M) x⁻¹, ⋯⟩ * ⟨(Units.coeHom M) x, ⋯⟩ = 1 | null | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.MeromorphicOn.codiscrete_setOfPred_meromorphicOrderAt_eq_zero_or_top._simp_1_2 | Mathlib.Analysis.Meromorphic.Order | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Std.Http.Internal.IndexMultiMap.0.Std.Internal.IndexMultiMap.insert.match_1.congr_eq_2 | Std.Http.Internal.IndexMultiMap | ∀ (motive : Option (Array ℕ) → Sort u_1) (x : Option (Array ℕ)) (h_1 : (idxs : Array ℕ) → motive (some idxs))
(h_2 : Unit → motive none),
x = none →
(match x with
| some idxs => h_1 idxs
| none => h_2 ()) ≍
h_2 () | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | The square `precomposeTransformSquare` respects compositions. | true |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_21 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam (∀ (n_1 : ℕ) (a : X.EllAdicCohomology ℓ n), Int.negSucc n_1 • a = -(↑n_1.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
_aux_Mathlib_Combinatorics_Quiver_Basic___unexpand_Quiver_Hom_1 | Mathlib.Combinatorics.Quiver.Basic | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Bicategory.Adj.iso₂Mk._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
(el : α.l ≅ β.l) (er : β.r ≅ α.r),
(CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) el.hom = er.hom →
(CategoryTheory.Bicategory.conjugateEquiv α.adj β.adj) el.inv = er.inv | null | false |
CategoryTheory.instPreadditiveOpposite._proof_10 | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (X Y : Cᵒᵖ)
(a : X ⟶ Y), -a + a = 0 | null | false |
String.Slice.Pos.byte.eq_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos) (h : pos ≠ s.endPos), pos.byte h = s.getUTF8Byte pos.offset ⋯ | null | true |
_private.Mathlib.Analysis.Convex.Jensen.0.StrictConvexOn.map_sum_eq_iff_of_pos._simp_1_3 | Mathlib.Analysis.Convex.Jensen | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | null | false |
_private.Mathlib.Analysis.CStarAlgebra.GelfandDuality.0.IsSelfAdjoint.nnnorm_sum_eq_sup._proof_1_2 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {ι : Type u_1} (j : ι) (s : Finset ι), j ∉ s → ∀ i ∈ s, ¬j = i | null | false |
CategoryTheory.Monoidal.InducingFunctorData.rec | Mathlib.CategoryTheory.Monoidal.Transport | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategoryStruct D] →
{F : CategoryTheory.Functor D C} →
{mo... | null | false |
AlgebraicGeometry.Scheme.Modules.pushforwardId | Mathlib.AlgebraicGeometry.Modules.Sheaf | (X : AlgebraicGeometry.Scheme) →
AlgebraicGeometry.Scheme.Modules.pushforward (CategoryTheory.CategoryStruct.id X) ≅
CategoryTheory.Functor.id X.Modules | The pushforward of sheaves of modules by the identity morphism identifies
to the identity functor. | true |
Mathlib.Linter.linter.style.setOption | Mathlib.Tactic.Linter.Style | Lean.Option Bool | The `setOption` linter emits a warning on a `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option.
It also warns on an option containing `maxHeartbeats`
(as these should be scoped as `set_option ... in` instead). | true |
_private.Lean.Message.0.Lean.MessageData.initFn._@.Lean.Message.1084813479._hygCtx._hyg.4 | Lean.Message | IO (Lean.Option ℕ) | null | false |
Ideal.quotientToQuotientRangePowQuotSucc | Mathlib.NumberTheory.RamificationInertia.Basic | {R : Type u} →
[inst : CommRing R] →
{S : Type v} →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
(P : Ideal S) →
[hfp : NeZero (p.ramificationIdx' P)] →
{i : ℕ} →
{a : S} →
a ∈ P ^ i →
... | `S ⧸ P` embeds into the quotient by `P^(i+1) ⧸ P^e` as a subspace of `P^i ⧸ P^e`. | true |
CategoryTheory.MonoidalLinear.whiskerLeft_smul | Mathlib.CategoryTheory.Monoidal.Linear | ∀ {R : Type u_1} {inst : Semiring R} {C : Type u_2} {inst_1 : CategoryTheory.Category.{v_1, u_2} C}
{inst_2 : CategoryTheory.Preadditive C} {inst_3 : CategoryTheory.Linear R C}
{inst_4 : CategoryTheory.MonoidalCategory C} {inst_5 : CategoryTheory.MonoidalPreadditive C}
[self : CategoryTheory.MonoidalLinear R C] (... | null | true |
CategoryTheory.ULift.upFunctor | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (ULift.{u₂, u₁} C) | The functorial version of `ULift.up`. | true |
Mathlib.Tactic.filterUpwards | Mathlib.Order.Filter.Defs | Lean.ParserDescr | `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
`h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
The list is an optional parameter, `[]` being its default value.
`filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ` is a short form for
`{ filter_upwards [h₁, ⋯, hₙ], intro a₁ a₂ ... | true |
EReal.sub_le_iff_le_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, b ≠ ⊥ ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ ⊥ → (a - b ≤ c ↔ a ≤ c + b) | null | true |
CategoryTheory.Subobject.ofMkLE | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{B A : C} →
(f : A ⟶ B) →
[inst_1 : CategoryTheory.Mono f] →
(X : CategoryTheory.Subobject B) →
CategoryTheory.Subobject.mk f ≤ X → (A ⟶ CategoryTheory.Subobject.underlying.obj X) | An inequality of subobjects is witnessed by some morphism between the corresponding objects. | true |
instTotallyDisconnectedSpaceMultiplicative | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α], TotallyDisconnectedSpace (Multiplicative α) | null | true |
BooleanAlgebra.toBooleanRing._proof_5 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (n : ℕ), (↑n).castDef = ↑n | null | false |
Module.Finite.addMonoidHom | Mathlib.LinearAlgebra.FreeModule.Finite.Matrix | ∀ (M : Type v) (N : Type w) [inst : AddCommGroup M] [Module.Finite ℤ M] [Module.Free ℤ M] [inst_3 : AddCommGroup N]
[Module.Finite ℤ N], Module.Finite ℤ (M →+ N) | null | true |
ContinuousAffineMap.const_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : Topolog... | null | true |
CategoryTheory.ObjectProperty.Is.rec | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{X : C} → {motive : P.Is X → Sort u_1} → ((prop : P X) → motive ⋯) → (t : P.Is X) → motive t | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c_1) =
(c = c_1) | null | true |
Lean.Core.Context.cancelTk? | Lean.CoreM | Lean.Core.Context → Option IO.CancelToken | If set, used to cancel elaboration from outside when results are not needed anymore. | true |
Std.ExtTreeSet.mem_inter_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
k ∈ t₁ ∩ t₂ ↔ k ∈ t₁ ∧ k ∈ t₂ | null | true |
HeytAlg.ext_iff | Mathlib.Order.Category.HeytAlg | ∀ {X Y : HeytAlg} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | null | true |
convexHull_neg | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) (-s) = -(convexHull 𝕜) s | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_i | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.dropPrefix?.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (list : List α) (h_1 : (list : List α) → motive list [])
(h_2 : (head : α) → (tail : List α) → motive [] (head :: tail))
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match list, [] with
| list, [] => h_1 list
... | null | true |
SimpleGraph.Subgraph.Connected.mono' | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph},
(∀ (v w : V), H.Adj v w → H'.Adj v w) → H.verts = H'.verts → H.Connected → H'.Connected | null | true |
dvd_mul_gcd_of_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ m * n → k ∣ m * gcd k n | null | true |
CategoryTheory.GlueData.mk | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
(J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
autoParam (∀ (i j : J), CategoryTheory.Mono (f i j)) CategoryTheory.GlueData.f_mono._autoParam →
(f_hasPullback :
... | null | true |
Lean.Elab.MonadParentDecl.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadParentDecl m → Sort u} →
(t : Lean.Elab.MonadParentDecl m) →
((getParentDeclName? : m (Option Lean.Name)) → motive { getParentDeclName? := getParentDeclName? }) → motive t | null | false |
_private.Lean.Parser.Basic.0.Lean.Parser.rawStrLitFnAux.errorUnterminated | Lean.Parser.Basic | String.Pos.Raw → Lean.Parser.ParserState → Lean.Parser.ParserState | Gives the "unterminated raw string literal" error.
| true |
Filter.div_le_div_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f₁ f₂ g : Filter α}, f₁ ≤ f₂ → f₁ / g ≤ f₂ / g | null | true |
RingEquiv.piOptionEquivProd | Mathlib.Algebra.Ring.Equiv | {ι : Type u_7} →
{R : Option ι → Type u_8} →
[inst : (i : Option ι) → NonUnitalNonAssocSemiring (R i)] →
((i : Option ι) → R i) ≃+* R none × ((i : ι) → R (some i)) | This is `Equiv.piOptionEquivProd` as a `RingEquiv`. | true |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConvConvSeq._regBuiltin.Lean.Elab.Tactic.Conv.evalConvConvSeq_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_1 | Mathlib.Analysis.Analytic.Composition | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c < min a b) = (c < a ∧ c < b) | null | false |
_private.Mathlib.Analysis.PSeries.0.Real.summable_nat_rpow_inv._simp_1_1 | Mathlib.Analysis.PSeries | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n | null | false |
ZeroAtInftyContinuousMap.unitizationEquiv_mul | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : R1Space X] [inst_2 : TopologicalSpace R]
[inst_3 : CommRing R] [inst_4 : IsTopologicalRing R] (f g : Unitization R (ZeroAtInftyContinuousMap X R)),
(ZeroAtInftyContinuousMap.unitizationEquiv X R) (f * g) =
(ZeroAtInftyContinuousMap.unitizatio... | null | true |
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ | null | false |
instDecidablePredPermMemSetDerangements | Mathlib.Combinatorics.Derangements.Finite | {α : Type u_1} → [DecidableEq α] → [Fintype α] → DecidablePred fun x => x ∈ derangements α | null | true |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α] (x : αᵐᵒᵖ), 1 * x = x | null | false |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M) (h : p ≤ q), (Submodule.inclusion h).range = Submodule.comap q.subtype p | null | true |
instSubsingleton | Init.Core | ∀ (p : Prop), Subsingleton p | null | true |
LinearMap.IsRightQuasiInverse.equiv | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V₂ : Type u_3} {V₃ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V₂] [inst_2 : Module K V₂]
[inst_3 : AddCommGroup V₃] [inst_4 : Module K V₃] {u : V₃ →ₗ[K] V₂} {v : V₂ →ₗ[K] V₃},
u.IsRightQuasiInverse v → v ∘ₗ u ≈ LinearMap.id | null | true |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {X Y : CategoryTheory.Under R} (f : X ⟶ Y),
((R.tensorProd S).map f).right =
CommRingCat.ofHom ↑(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom f)) | null | true |
Complex.isAlgebraic_sin_rat_mul_pi | Mathlib.NumberTheory.Niven | ∀ (q : ℚ), IsAlgebraic ℤ (Complex.sin (↑q * ↑Real.pi)) | `sin(q * π)` for `q : ℚ` is algebraic over `ℤ`, using the complex `sin` function. | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {α : Sort u_1} (c0 c1 : Bool) {a b : α}, (bif c0 then a else bif c1 then a else b) = bif !c0 && !c1 then b else a | null | true |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
[inst : IsWellOrder β s] [inst_1 : IsTrans γ t] (f : InitialSeg r s) (g : PrincipalSeg s t) (a : α),
(f.transPrincipal g).toRelEmbedding a = g.toRelEmbedding (f a) | null | true |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_2} [inst : Ring R] {J : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_1, max u_4 u_1} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (x x_1 : J)
(f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((Categor... | null | false |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_15} {Ms : η → Type u_16} {Ns : η → Type u_17} [inst : (j : η) → Mul (Ms j)]
[inst_1 : (j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j),
(MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm | null | true |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L)
{K' : LieSubalgebra R L} (h : K ≤ K'),
(∃ I, LieIdeal.toLieSubalgebra R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K | null | true |
Pi.evalNonUnitalRingHom._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_2} (f : I → Type u_1) [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (i : I) (x y : (i : I) → f i),
(↑(Pi.evalAddMonoidHom f i)).toFun (x + y) =
(↑(Pi.evalAddMonoidHom f i)).toFun x + (↑(Pi.evalAddMonoidHom f i)).toFun y | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : [] ≠ [] → Prop) (h : [] ≠ []), motive h | null | false |
CategoryTheory.Cokleisli.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {U : CategoryTheory.Comonad C} → C → CategoryTheory.Cokleisli U | null | false |
ContDiffBump.rOut | Mathlib.Analysis.Calculus.BumpFunction.Basic | {E : Type u_1} → {c : E} → ContDiffBump c → ℝ | real numbers `0 < rIn < rOut` | true |
CuspForm.instAddCommGroup._proof_5 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ},
autoParam (∀ (n : ℕ) (x : CuspForm Γ k), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.Complement | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_2} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → {p : Submodule R M} → p.ClosedComplemented → Submodule R M | An arbitrary choice of topological complement of a topologically complemented submodule. | true |
NormedAddCommGroup.ofCoreReplaceTopology._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : Norm E]
[T : TopologicalSpace E] (core : NormedSpace.Core 𝕜 E) (H : T = PseudoEMetricSpace.toUniformSpace.toTopologicalSpace)
{x y : E}, dist x y = 0 → x = y | null | false |
ContinuousLinearEquiv.summable | Mathlib.Topology.Algebra.InfiniteSum.Module | ∀ {ι : Type u_4} {R : Type u_6} {R₂ : Type u_7} {M : Type u_8} {M₂ : Type u_9} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₂]
[inst_5 : Module R₂ M₂] [inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace M₂] {σ : R →+* R₂} {σ' : R₂ →+* R}
... | null | true |
Std.HashSet.Raw.Equiv.of_forall_contains_eq | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [LawfulBEq α],
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | null | true |
FreeAddMonoid.casesOn_zero | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {motive : FreeAddMonoid α → Sort u_6} (zero : motive 0)
(of_add : (x : α) → (xs : FreeAddMonoid α) → motive (FreeAddMonoid.of x + xs)),
FreeAddMonoid.casesOn 0 zero of_add = zero | null | true |
ContinuousMap.coeFnRingHom_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Semiring β]
[inst_3 : IsTopologicalSemiring β] (f : C(α, β)) (a : α), ContinuousMap.coeFnRingHom f a = f a | null | true |
_private.Std.Sync.Broadcast.0.Std.Bounded.State.size | Std.Sync.Broadcast | {α : Type} → Std.Bounded.State✝ α → ℕ | Current number of messages stored in the circular buffer.
| true |
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | ∀ (f : Type u₀ → Type u₁) [inst : EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α),
(EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x | null | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a.bit1.testBit 0 = true | null | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(x : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((header : Lean.TSyntax `Lean.Parser.Module.header) →
(parserState : Lean.Parser.ModuleParserS... | null | false |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C}
(g h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h | A morphism `f` is an epimorphism if it can be cancelled when precomposed. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceSub._regBuiltin.Int32.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.114 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | Std.Time.Hour.Offset → Std.Time.Hour.Offset → Prop | null | false |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} {xs : Vector { x // p x } n} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → Vector.findFinIdx? f xs = Vector.findFinIdx? g xs.unattach | null | true |
AffineIsometryEquiv._sizeOf_1 | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
{inst : NormedField 𝕜} →
{inst_1 : SeminormedAddCommGroup V} →
{inst_2 : NormedSpace 𝕜 V} →
{inst_3 : PseudoMetricSpace P} →
{inst_4 : Nor... | null | false |
String.startsWith_toSlice | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String},
s.toSlice.startsWith pat = s.startsWith pat | null | true |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F] {L : E →L[... | null | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
X.ofLEMk f h =
CategoryTheory.CategoryStruct.comp (X.ofLE (CategoryTheory.Subobject.mk f) h)
(CategoryTheory.Subobjec... | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.Simp.SimpTheorems.2970893097._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.SimpTheorems | IO (IO.Ref Lean.Meta.SimpExtensionMap) | null | false |
String.Slice.Pos.ofSlice_le_ofSlice_iff | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {q r : (s.slice p₀ p₁ h).Pos},
String.Slice.Pos.ofSlice q ≤ String.Slice.Pos.ofSlice r ↔ q ≤ r | null | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Command.CommandElab | null | false |
Measurable.fun_neg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : Neg G] [inst_1 : MeasurableSpace G] [MeasurableNeg G] {m : MeasurableSpace α}
{f : α → G}, Measurable f → Measurable fun i => -f i | null | true |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.DocumentFilter → Sort u} →
((language? scheme? pattern? : Option String) →
motive { language? := language?, scheme? := scheme?, pattern? := pattern? }) →
(t : Lean.Lsp.DocumentFilter) → motive t | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | ∀ {ι : Type u_1} {s : Finset ι} (motive : Subtype (Membership.mem s) → Prop) (x : Subtype (Membership.mem s)),
(∀ (i : ι) (hi : i ∈ s), motive ⟨i, hi⟩) → motive x | null | false |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | Sort u → {𝕜 : Type u_4} → {E : Type u_5} → Inner 𝕜 E → {𝕜' : Type u_4} → {E' : Type u_5} → Inner 𝕜' E' → Sort u | null | false |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : MonoidWithZero R] (a : R), a • 0 = 0 | null | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List α | Returns a list of all keys present in the tree map in ascending order. | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] {m : M} (motive : IsAddUnit m → Prop) (h : IsAddUnit m),
(∀ (u : AddUnits M) (hu : ↑u = m), motive ⋯) → motive h | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : DivInvMonoid α], ULift.divInvMonoid = Function.Injective.divInvMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
RestrictedProduct.mapAlong_continuous | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι₁ : Type u_3} {ι₂ : Type u_4} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_6) [inst : (i : ι₁) → TopologicalSpace (R₁ i)]
[inst_1 : (i : ι₂) → TopologicalSpace (R₂ i)] {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂} {A₁ : (i : ι₁) → Set (R₁ i)}
{A₂ : (i : ι₂) → Set (R₂ i)} (f : ι₂ → ι₁) (hf : Filter.Tendsto f 𝓕₂ 𝓕₁) (φ : (j : ... | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.Ici_nsmul_eq.match_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | null | false |
Int8.shiftLeft | Init.Data.SInt.Basic | Int8 → Int8 → Int8 | Bitwise left shift for 8-bit signed integers. Usually accessed via the `<<<` operator.
Signed integers are interpreted as bitvectors according to the two's complement representation.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Mathlib.Analysis.Analytic.CPolynomialDef.0.HasFiniteFPowerSeriesOnBall.eq_partialSum._simp_1_1 | Mathlib.Analysis.Analytic.CPolynomialDef | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.