name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.Even.eq_1 | Mathlib.Analysis.Fourier.ZMod | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] (f : α → β), Function.Even f = ∀ (a : α), f (-a) = f a | null | true |
SupHom.copy._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Max α] [inst_1 : Max β] (f : SupHom α β) (f' : α → β),
f' = ⇑f → ∀ (a b : α), f' (a ⊔ b) = f' a ⊔ f' b | null | false |
SignType.LE | Mathlib.Basic.Sign.Defs | SignType → SignType → Prop | The less-than-or-equal relation on signs. | true |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.bddAbove_rayleighQuotient.match_1_1 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (x : ℝ) (motive : (x ∈ Set.range fun x => |T.rayleighQuotient x|) → Prop)
(x_1 : x ∈ Set.range fun x => |T.rayleighQuotient x|),
(∀ (y : E) (h : (fun x => |T.rayleighQuotient x|) ... | null | false |
Profinite.toCompHaus.reflective._proof_2 | Mathlib.Topology.Category.Profinite.Basic | (CompHausLike.toCompHausLike Profinite.toCompHaus.reflective._proof_1).Full | null | false |
Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {p : Type u_2} {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : DecidableEq n] [inst_2 : DecidableEq p]
[inst_3 : Fintype n] [inst_4 : Fintype p] (M : Matrix p p 𝕜) (e : p ≃ n),
(∃ L L' D,
(List.map Matrix.TransvectionStruct.toMatrix L).prod * (Matrix.reindexAlgEquiv 𝕜 𝕜 e) M *
(List.... | Reduction to diagonal form by elementary operations is invariant under reindexing. | true |
Matrix.discr | Mathlib.LinearAlgebra.Matrix.Charpoly.Disc | {R : Type u_1} → {n : Type u_2} → [CommRing R] → [Fintype n] → [DecidableEq n] → Matrix n n R → R | The discriminant of a matrix is defined to be the discriminant of its characteristic
polynomial. | true |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_hom | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).hom =
CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct... | null | true |
_private.Mathlib.Algebra.MonoidAlgebra.Module.0.MonoidAlgebra.mem_supported'._simp_1_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
{s : Set M} {x : MonoidAlgebra S M}, (x ∈ MonoidAlgebra.supported R S s) = (↑x.coeff.support ⊆ s) | null | false |
Monoid.Coprod.swap_bijective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
Function.Bijective ⇑(Monoid.Coprod.swap M N) | null | true |
IsLeftCancelMul.mk | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_2} [inst : Mul G], (∀ (a : G), IsLeftRegular a) → IsLeftCancelMul G | null | true |
Associates.instCommMonoid._proof_4 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦1 * a⟧ = ⟦a⟧ | null | false |
Set.inv_smul_set_distrib₀ | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} [inst : GroupWithZero α] (a : α) (s : Set α), (a • s)⁻¹ = MulOpposite.op a⁻¹ • s⁻¹ | null | true |
DFA.recOn | Mathlib.Computability.DFA | {α : Type u} →
{σ : Type v} →
{motive : DFA α σ → Sort u_1} →
(t : DFA α σ) →
((step : σ → α → σ) →
(start : σ) → (accept : Set σ) → motive { step := step, start := start, accept := accept }) →
motive t | null | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.span_range_mk_kerGen | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_4}
{P : Algebra.Generators R S ι} {σ : Type u_5} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
Submodule.span (Algebra.Generators.Presentatio... | null | true |
Fin.partialProd_succ' | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin (n + 1) → M) (j : Fin (n + 1)),
Fin.partialProd f j.succ = f 0 * Fin.partialProd (Fin.tail f) j | null | true |
Heyting.Regular.toRegular._proof_1 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a : α), Heyting.IsRegular aᶜᶜ | null | false |
RatFunc.valuationIdeal._proof_2 | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [inst_2 : v.IsNontrivial] [inst_3 : Valuation.IsTrivialOn K v] (hle : v RatFunc.X ≤ 1),
Polynomial K ∙ RatFunc.uniformizingPolynomial hle ≠ ⊥ | null | false |
SecondCountableTopology.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{motive : SecondCountableTopology α → Sort u_1} →
(t_1 : SecondCountableTopology α) →
((is_open_generated_countable : ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b) → motive ⋯) → motive t_1 | null | false |
Vector.set_append | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m} {i : ℕ} {x : α} (h : i < n + m),
(xs ++ ys).set i x h = if h' : i < n then xs.set i x h' ++ ys else xs ++ ys.set (i - n) x ⋯ | null | true |
Std.Http.Response.ok | Std.Http.Data.Response | Std.Http.Response.Builder | Creates a new HTTP Response builder with the 200 status code.
| true |
CategoryTheory.IsVanKampenColimit.map_reflective | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [CategoryTheory.Limits.HasColimitsOfShape J C]
{Gl : CategoryTheory.Functor C D} {Gr : CategoryTheory.Functor D C} (adj : Gl ⊣ Gr) [Gr.F... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_isSome_maxKey?_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
TopologicalSpace.Compacts.isometry_toCloseds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α], Isometry TopologicalSpace.Compacts.toCloseds | null | true |
EisensteinSeries.gammaSetEquiv._proof_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Defs | ∀ {N r : ℕ} (a : Fin 2 → ZMod N) [inst : NeZero r] (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
(v :
↑(EisensteinSeries.gammaSet N r (Matrix.vecMul a ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)))),
(fun v => ⟨Matrix.vecMul ↑v ↑γ, ⋯⟩) ((fun v => ⟨Matrix.vecMul ↑v ↑γ⁻¹, ⋯⟩) v) = v | null | false |
Mathlib.Meta.Positivity.pos_of_isNNRat | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n d : ℕ} [inst : Semiring A] [inst_1 : LinearOrder A] [IsStrictOrderedRing A],
Mathlib.Meta.NormNum.IsNNRat e n d → decide (0 < n) = true → 0 < e | null | true |
_private.Mathlib.Topology.WithTopology.0.WithTopology.isClosed_iff._simp_1_2 | Mathlib.Topology.WithTopology | ∀ {X : Type u_1} (t : TopologicalSpace X) {s : Set (WithTopology X t)},
IsOpen s = IsOpen (WithTopology.toTopology t ⁻¹' s) | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof?.go._f | Lean.Meta.Tactic.Grind.Split | (proof : Lean.Expr) → Lean.Expr.below proof → Lean.MetaM (Option Lean.Expr) | null | false |
Lean.Meta.ReduceMatcherResult.casesOn | Lean.Meta.WHNF | {motive : Lean.Meta.ReduceMatcherResult → Sort u} →
(t : Lean.Meta.ReduceMatcherResult) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.reduced val)) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.stuck val)) →
motive Lean.Meta.ReduceMatcherResult.notMatcher → motive Lean.... | null | false |
PositiveContinuousLinearMap.id | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | (R : Type u_1) →
(E₁ : Type u_2) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid E₁] →
[inst_2 : PartialOrder E₁] → [inst_3 : Module R E₁] → [inst_4 : TopologicalSpace E₁] → E₁ →P[R] E₁ | The identity as a positive continuous linear map. | true |
OpenPartialHomeomorph.singletonChartedSpace._proof_2 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] {α : Type u_2} [inst_1 : TopologicalSpace α]
(e : OpenPartialHomeomorph α H), e ∈ {e} | null | false |
SSetPair.instHasCokernelFunctorChainComplexNatChainComplexFunctorLeftToRight | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Relative | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C], CategoryTheory.Limits.HasCokernel (SSetPair.chainComplexFunctorLeftToRight C) | null | true |
OpenPartialHomeomorph.coe_ofContinuousOpen | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialEquiv X Y)
(hc : ContinuousOn (↑e) e.source) (ho : IsOpenMap ↑e) (hs : IsOpen e.source),
↑(OpenPartialHomeomorph.ofContinuousOpen e hc ho hs) = ↑e | null | true |
_private.Plausible.Gen.0.Plausible.test | Plausible.Gen | ℕ → Plausible.Gen ℕ | null | true |
CategoryTheory.GradedObject.TriangleIndexData.p₂₃ | Mathlib.CategoryTheory.GradedObject.Unitor | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₃ : Type u_3} →
{J : Type u_4} →
[inst : Zero I₂] →
{r : I₁ × I₂ × I₃ → J} → {π : I₁ × I₃ → J} → CategoryTheory.GradedObject.TriangleIndexData r π → I₂ × I₃ → I₃ | a map `I₂ × I₃ → I₃` | true |
Filter.empty_notMem._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α) [f.NeBot], (∅ ∈ f) = False | null | false |
MulSemiringAction.toAlgEquiv.congr_simp | Mathlib.FieldTheory.Galois.Basic | ∀ {G : Type u_1} (R : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Group G] [inst_4 : MulSemiringAction G A] [inst_5 : SMulCommClass G R A] (g g_1 : G),
g = g_1 → MulSemiringAction.toAlgEquiv R A g = MulSemiringAction.toAlgEquiv R A g_1 | null | true |
GroupNorm.coe_sup._simp_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] (p q : GroupNorm E), ⇑p ⊔ ⇑q = ⇑(p ⊔ q) | null | false |
Std.Sat.CNF.Clause.not_sat_unit_iff | Std.Sat.CNF.Unit | ∀ {α : Type u_1} {a : α → Bool} {atom : α} {pol : Bool},
¬Std.Sat.CNF.Clause.Sat a (Std.Sat.CNF.Clause.unit atom pol) ↔ a atom = !pol | null | true |
ULift.down_ratCast | Mathlib.Algebra.Field.ULift | ∀ {α : Type u} [inst : RatCast α] (q : ℚ), (↑q).down = ↑q | null | true |
RelIso.relEmbeddingCongr_symm_apply | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_5} {β₁ : Type u_6} {α₂ : Type u_7} {β₂ : Type u_8} {r₁ : α₁ → α₁ → Prop} {s₁ : β₁ → β₁ → Prop}
{r₂ : α₂ → α₂ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r r₂) (e₂ : s₁ ≃r s₂) (f₂ : r₂ ↪r s₂),
(e₁.relEmbeddingCongr e₂).symm f₂ = (e₁.toRelEmbedding.trans f₂).trans e₂.symm.toRelEmbedding | null | true |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs._sparseCasesOn_1 | Mathlib.Tactic.MoveAdd | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name... | null | false |
CategoryTheory.instComonadicLeftAdjointCoalgebraForget | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(G : CategoryTheory.Comonad C) → CategoryTheory.ComonadicLeftAdjoint G.forget | null | true |
Chebyshev.integral_theta_div_log_sq_isLittleO | Mathlib.NumberTheory.Chebyshev | (fun x => ∫ (t : ℝ) in 2..x, Chebyshev.theta t / (t * Real.log t ^ 2)) =o[Filter.atTop] fun x => x / Real.log x | null | true |
typeToPointed._proof_3 | Mathlib.CategoryTheory.Category.Pointed | ∀ (x : Type u_1),
Option.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id x))
{ X := Option x, point := none }.point =
Option.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id x))
{ X := Option x, point := none }.point | null | false |
MeasureTheory.lintegral_sub_right_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : AddGroup G] [MeasurableAdd G]
[μ.IsAddRightInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (x - g) ∂μ = ∫⁻ (x : G), f x ∂μ | null | true |
Std.HashSet.Raw.mem_toList._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, (k ∈ m.toList) = (k ∈ m) | null | false |
WithTop.measurable_of_measurable_comp_coe | Mathlib.MeasureTheory.Constructions.BorelSpace.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
[inst_3 : MeasurableSpace ι] [BorelSpace ι] {α : Type u_2} {mα : MeasurableSpace α} {f : WithTop ι → α},
(Measurable fun p => f ↑p) → Measurable f | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Ordering.swap.match_1.splitter | Std.Data.DTreeMap.Internal.Model | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.eq) → (Unit → motive Ordering.gt) → motive x | null | true |
Option.pfilter_filter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : α → Bool} {q : (a : α) → Option.filter p o = some a → Bool},
(Option.filter p o).pfilter q = o.pfilter fun a h => if h' : p a = true then q a ⋯ else false | null | true |
Lean.Compiler.LCNF.Check.Pure.State.all | Lean.Compiler.LCNF.Check | Lean.Compiler.LCNF.Check.Pure.State → Lean.FVarIdHashSet | All free variables found | true |
Lean.Meta.LazyDiscrTree.instEmptyCollectionTrie | Lean.Meta.LazyDiscrTree | {α : Type} → EmptyCollection (Lean.Meta.LazyDiscrTree.Trie α) | null | true |
Lean.Lsp.CompletionItemTag.deprecated.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemTag.deprecated = 1 | null | true |
LowerSet.mem_Iic_iff._simp_1 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ LowerSet.Iic a) = (b ≤ a) | null | false |
tendsto_birkhoffAverage_apply_sub_birkhoffAverage' | Mathlib.Dynamics.BirkhoffSum.NormedSpace | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] (𝕜 : Type u_3) [inst_1 : RCLike 𝕜]
[inst_2 : NormedSpace 𝕜 E] {g : α → E},
Bornology.IsBounded (Set.range g) →
∀ (f : α → α) (x : α),
Filter.Tendsto (fun n => birkhoffAverage 𝕜 f g n (f x) - birkhoffAverage 𝕜 f g n x) Filter.atTop (nhds 0) | If a function `g` is bounded,
then the difference between Birkhoff averages of `g`
along the orbit of `f x` and along the orbit of `x`
tends to zero.
See also `tendsto_birkhoffAverage_apply_sub_birkhoffAverage`. | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.linearIndependent_unique_iff._simp_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Sort u_1} [inst : Unique α] {p : α → Prop}, (∀ (a : α), p a) = p default | null | false |
EisensteinSeries.G2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | UpperHalfPlane → ℂ | The Eisenstein series of weight `2` and level `1` defined as the conditional sum
of `m` in `[N,N]` of `e2Summand m`. This sum over symmetric intervals is handy in showing it is
Summable. | true |
WeierstrassCurve.Affine.baseChange_polynomialX | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [inst_1 : CommRing S] {A : Type u}
[inst_2 : CommRing A] {B : Type v} [inst_3 : CommRing B] [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScal... | null | true |
Subsemiring.comap_comap | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
[inst_2 : NonAssocSemiring T] (s : Subsemiring T) (g : S →+* T) (f : R →+* S),
Subsemiring.comap f (Subsemiring.comap g s) = Subsemiring.comap (g.comp f) s | null | true |
lift_cardinalMk_eq_lift_cardinalMk_field_pow_lift_rank | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ (K : Type u) (V : Type v) [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V] [Module.Finite K V],
Cardinal.lift.{u, v} (Cardinal.mk V) = Cardinal.lift.{v, u} (Cardinal.mk K) ^ Cardinal.lift.{u, v} (Module.rank K V) | null | true |
MeasureTheory.locallyIntegrableOn_congr | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f g : X → ε} {μ : MeasureTheory.Measure X} {s : Set X},
f =ᵐ[μ.restrict s] g → (MeasureTheory.LocallyIntegrableOn f s μ ↔ MeasureTheory.LocallyIntegrableOn g s μ) | null | true |
Nat.repr_of_ge | Init.Data.Nat.ToString | ∀ {n : ℕ}, 10 ≤ n → n.repr = (n / 10).repr ++ String.singleton (n % 10).digitChar | null | true |
SimpleGraph.neighborSet_sup | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {G₁ G₂ : SimpleGraph V} (v : V), (G₁ ⊔ G₂).neighborSet v = G₁.neighborSet v ∪ G₂.neighborSet v | null | true |
CategoryTheory.Precoverage.Saturate.recOn | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} {X : C} {a : CategoryTheory.Sieve X}
(t : J.Saturate X a),
(∀ (X : C) (S : CategoryTheory.Presieve X) (hS : S ∈ J.coverings X), motive X (Cate... | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.sshiftRight_eq_sshiftRight_of_le._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {m : ℕ} {n : ℕ}, w ≤ n → ∀ (i : ℕ), n + i < w → False | null | false |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.natDegree_hasseDeriv_le._simp_1_6 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
Int32.neg_mul_neg | Init.Data.SInt.Lemmas | ∀ (a b : Int32), -a * -b = a * b | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.recOn | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(t : Nat.NatOffset✝) →
((n : ℕ) → motive (Nat.NatOffset.const✝ n)) →
((e o : Lean.Expr) → (n : ℕ) → motive (Nat.NatOffset.offset✝ e o n)) → motive t | null | false |
StructureGroupoid.noConfusionType | Mathlib.Geometry.Manifold.StructureGroupoid | Sort u →
{H : Type u_2} →
[inst : TopologicalSpace H] →
StructureGroupoid H → {H' : Type u_2} → [inst' : TopologicalSpace H'] → StructureGroupoid H' → Sort u | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.mk._flat_ctor | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{F : CategoryTheory.Functor J C} →
{c : CategoryTheory.Limits.Cocone F} →
{X Y : C} →
{p : X ⟶ Y} →
{f : ... | null | false |
Std.Do.WP.withReader_MonadWithReader | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ρ α : Type u} {Q : Std.Do.PostCond α ps} [inst : MonadWithReaderOf ρ m]
[inst_1 : Std.Do.WP m ps] (f : ρ → ρ) (x : m α),
(Std.Do.wp (withReader f x)).apply Q = (Std.Do.wp (MonadWithReaderOf.withReader f x)).apply Q | null | true |
CategoryTheory.Abelian.SpectralObject.fromOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
(X : CategoryTheory.Abelian.SpectralObject C ι) →
{i j k : ι} →
(f : i ⟶ j) →
... | The map `H^n(f) ⟶ H^n(f ≫ g)` factors through `opZ^n(f, g)`. | true |
ContinuousLinearEquiv.ofFinrankEq._proof_2 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜], StrongRankCondition 𝕜 | null | false |
Matrix.instAddCommMagma | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [AddCommMagma α] → AddCommMagma (Matrix m n α) | null | true |
Filter.Tendsto.eventually_intervalIntegrable_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ι : Type u_1} {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
{l l' : Filter ℝ},
StronglyMeasurableAtFilter f l' μ →
∀ [Filter.TendstoIxxClass Set.Ioc l l'] [l'.IsMeasurablyGenerated],
μ.FiniteAtFilter l' →
∀ {c : E},
Filter.Tendsto f (l' ⊓ Measu... | Let `l'` be a measurably generated filter; let `l` be a of filter such that each `s ∈ l'`
eventually includes `Ioc u v` as both `u` and `v` tend to `l`. Let `μ` be a measure finite at `l'`.
Suppose that `f : ℝ → E` has a finite limit at `l' ⊓ ae μ`. Then `f` is interval integrable on
`u..v` provided that both `u` and ... | true |
_private.Lean.Meta.PProdN.0.Lean.Meta.PProdN.unpack.go._sparseCasesOn_1 | Lean.Meta.PProdN | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
SchwartzMap.compCLM_apply | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_2) {D : Type u_4} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : RCLike 𝕜] [inst_5 : NormedAddCommGroup D]
[inst_6 : NormedSpace ℝ D] [inst_7 : NormedSpace 𝕜 F] {g : D → E} (hg : Function.Ha... | null | true |
Subsemigroup.recOn | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_3} →
[inst : Mul M] →
{motive : Subsemigroup M → Sort u} →
(t : Subsemigroup M) →
((carrier : Set M) →
(mul_mem' : ∀ {a b : M}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
motive { carrier := carrier, mul_mem' := mul_mem' }) →
motive t | null | false |
AddCommGrpCat.isFinite | Mathlib.Algebra.Category.Grp.IsFinite | CategoryTheory.ObjectProperty AddCommGrpCat | The Serre class of finite abelian groups
in the category of abelian groups. | true |
AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_point_assoc | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) (x x' : ↑X.toTopCat) (hxx' : x = x') {Z : CommRingCat}
(h : X.presheaf.stalk x' ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x)
(CategoryTheory.CategoryStruct.comp (X.presheaf.stalkSpecializes ⋯) h) =
... | null | true |
FractionalIdeal.mul_induction_on | 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]
{I J : FractionalIdeal S P} {C : P → Prop} {r : P},
r ∈ I * J → (∀ i ∈ I, ∀ j ∈ J, C (i * j)) → (∀ (x y : P), C x → C y → C (x + y)) → C r | null | true |
ULift.commMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : CommMonoid α], ULift.commMonoid = Function.Injective.commMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ | null | true |
Std.DTreeMap.Internal.Impl.erase._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[Ord α] →
α →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) t.size | null | false |
Matrix.transpose_reindex | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (eₘ : m ≃ l) (eₙ : n ≃ o) (M : Matrix m n α),
((Matrix.reindex eₘ eₙ) M).transpose = (Matrix.reindex eₙ eₘ) M.transpose | null | true |
_private.Mathlib.Algebra.Homology.Localization.0.HomotopyCategory.quotient_map_mem_quasiIso_iff._simp_1_3 | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c} (f : K ⟶ L)
[inst_2 : ∀ (i : ι), K.HasHomology i] [inst_3 : ∀ (i : ι), L.HasHomology i], QuasiIso f = ∀ (i : ι), QuasiIsoAt f i | null | false |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp_f₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁.Hom S₂) (g : S₂.Hom S₃),
(f.comp g).f₂ = CategoryTheory.CategoryStruct.comp f.f₂ g.f₂ | null | true |
Sum.Ioc_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioc (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioc b₁ b₂) | null | true |
BialgHom.instOneWithConv | Mathlib.RingTheory.Bialgebra.Convolution | {R : Type u_1} →
{A : Type u_2} →
{C : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : Semiring C] → [inst_3 : Bialgebra R A] → [inst_4 : Bialgebra R C] → One (WithConv (C →ₐc[R] A)) | null | true |
ModelWithCorners.Boundaryless.mk | Mathlib.Geometry.Manifold.IsManifold.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},
Set.range ↑I = Set.univ → I.Boundaryless | null | true |
_private.Mathlib.NumberTheory.Primorial.0.«_aux_Mathlib_NumberTheory_Primorial___macroRules__private_Mathlib_NumberTheory_Primorial_0_term_#_1» | Mathlib.NumberTheory.Primorial | Lean.Macro | null | false |
MeasureTheory.AEEqFun.comp_comp | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace δ] [inst_2 : TopologicalSpace β] [inst_3 : TopologicalSpace γ] (g : γ → δ) (g' : β → γ)
(hg : Continuous g) (hg' : Continuous g') (f : α →ₘ[μ] β),
MeasureTheory.AEEqFun... | null | true |
Submodule.mem_span_finset | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Finset M}
{x : M}, x ∈ Submodule.span R ↑s ↔ ∃ f, Function.support f ⊆ ↑s ∧ ∑ a ∈ s, f a • a = x | null | true |
CategoryTheory.Functor.FullyFaithful.mulEquivEnd_apply_asHom | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{f : CategoryTheory.Functor C D} (hf : f.FullyFaithful) (X : C) (a : CategoryTheory.End X),
((hf.mulEquivEnd X) a).asHom = f.map a.asHom | null | true |
Lean.Expr.ProdTree.getType._f | Mathlib.Tactic.ProdAssoc | (x : Lean.Expr.ProdTree) → Lean.Expr.ProdTree.below x → Lean.Expr | null | false |
TopologicalSpace.Opens.map_def._proof_1 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) (X_1 : TopologicalSpace.Opens ↑Y),
{ down := { down := ⋯ } } =
CategoryTheory.CategoryStruct.id { carrier := ⇑(CategoryTheory.ConcreteCategory.hom f) ⁻¹' ↑X_1, is_open' := ⋯ } | null | false |
Matrix.IsHermitian.submatrix | Mathlib.LinearAlgebra.Matrix.Hermitian | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_4} [inst : Star α] {A : Matrix n n α},
A.IsHermitian → ∀ (f : m → n), (A.submatrix f f).IsHermitian | null | true |
_private.Mathlib.MeasureTheory.SetAlgebra.0.MeasureTheory.GenerateSetAlgebra.below.compl | Mathlib.MeasureTheory.SetAlgebra | ∀ {α : Type u_2} {𝒜 : Set (Set α)} {motive : (a : Set α) → MeasureTheory.GenerateSetAlgebra✝ 𝒜 a → Prop} (s : Set α)
(hs : MeasureTheory.GenerateSetAlgebra✝ 𝒜 s),
MeasureTheory.GenerateSetAlgebra.below✝ hs → motive s hs → MeasureTheory.GenerateSetAlgebra.below✝ ⋯ | null | true |
_private.Lean.Compiler.Specialize.0.Lean.Compiler.initFn._@.Lean.Compiler.Specialize.149776412._hygCtx._hyg.2 | Lean.Compiler.Specialize | IO (Lean.ParametricAttribute (Array ℕ)) | null | false |
Std.IteratorLoop.WithWF.mk.injEq | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β] {γ : Type x}
{PlausibleForInStep : β → γ → ForInStep γ → Prop} {hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep}
(it : Std.IterM m β) (acc : γ) (it_1 : Std.IterM m β) (acc_1 : γ),
({ it := it, acc := acc } = { it := it_1, acc... | null | true |
SimpleGraph.regularityReduced_anti | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
{P : Finpartition A} {G : SimpleGraph α} [inst_3 : DecidableRel G.Adj] {ε δ₁ δ₂ : 𝕜},
δ₁ ≤ δ₂ → SimpleGraph.regularityReduced P G ε δ₂ ≤ SimpleGraph.regularityReduced P G ε δ₁ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.