name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
IsBezout.span_pair_isPrincipal | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : Ring R] [IsBezout R] (x y : R), Submodule.IsPrincipal (Ideal.span {x, y}) |
PrincipalSeg.isSuccPrelimit_apply_iff | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : PartialOrder α] [inst_1 : PartialOrder β]
(f : PrincipalSeg (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2),
Order.IsSuccPrelimit (f.toRelEmbedding a) ↔ Order.IsSuccPrelimit a |
CategoryTheory.Limits.WalkingPair.equivBool._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ (j : CategoryTheory.Limits.WalkingPair),
(fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left)
((fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
j) =
j |
ProfiniteAddGrp.ofHom_apply | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : Type u} [inst : AddGroup X] [inst_1 : TopologicalSpace X] [inst_2 : IsTopologicalAddGroup X]
[inst_3 : CompactSpace X] [inst_4 : TotallyDisconnectedSpace X] [inst_5 : AddGroup Y] [inst_6 : TopologicalSpace Y]
[inst_7 : IsTopologicalAddGroup Y] [inst_8 : CompactSpace Y] [inst_9 : TotallyDisconnectedSpace Y] (f : X →ₜ+ Y)
(x : X), (ProfiniteAddGrp.Hom.hom (ProfiniteAddGrp.ofHom f)) x = f x |
minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → Set (Ideal R) |
Nondet.ofListM | Batteries.Control.Nondet.Basic | {σ : Type} → {m : Type → Type} → [Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → List (m α) → Nondet m α |
CategoryTheory.MonObj._aux_Mathlib_CategoryTheory_Monoidal_Mon____unexpand_CategoryTheory_MonObj_mul_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | Lean.PrettyPrinter.Unexpander |
HasFDerivWithinAt.of_restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
[inst_8 : NormedSpace 𝕜 F] [inst_9 : NormedSpace 𝕜' F] [inst_10 : IsScalarTower 𝕜 𝕜' F] {f : E → F} {f' : E →L[𝕜'] F}
{s : Set E} {x : E} {g' : E →L[𝕜] F},
HasFDerivWithinAt f g' s x → ContinuousLinearMap.restrictScalars 𝕜 f' = g' → HasFDerivWithinAt f f' s x |
_private.Mathlib.NumberTheory.Padics.PadicVal.Basic.0.padicValRat.lt_sum_of_lt._simp_1_1 | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) |
MulAction.IsBlock.univ | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X], MulAction.IsBlock G Set.univ |
Std.HashSet.getD_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback |
CompHausLike.finiteCoproduct.desc | Mathlib.Topology.Category.CompHausLike.Limits | {P : TopCat → Prop} →
{α : Type w} →
[inst : Finite α] →
(X : α → CompHausLike P) →
[inst_1 : CompHausLike.HasExplicitFiniteCoproduct X] →
{B : CompHausLike P} → ((a : α) → X a ⟶ B) → (CompHausLike.finiteCoproduct X ⟶ B) |
ContinuousMap.induction_on | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {s : Set 𝕜} {p : C(↑s, 𝕜) → Prop},
(∀ (r : 𝕜), p (ContinuousMap.const (↑s) r)) →
p (ContinuousMap.restrict s (ContinuousMap.id 𝕜)) →
p (star (ContinuousMap.restrict s (ContinuousMap.id 𝕜))) →
(∀ (f g : C(↑s, 𝕜)), p f → p g → p (f + g)) →
(∀ (f g : C(↑s, 𝕜)), p f → p g → p (f * g)) →
((∀ f ∈ (polynomialFunctions s).starClosure, p f) → ∀ (f : C(↑s, 𝕜)), p f) → ∀ (f : C(↑s, 𝕜)), p f |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.card_edgeFinset._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {α : Type u_4} {f : Sym2 α → Prop}, (∀ (x : Sym2 α), f x) = ∀ (x y : α), f s(x, y) |
List.Vector.continuous_eraseIdx | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}, Continuous (List.Vector.eraseIdx i) |
_private.Mathlib.CategoryTheory.ObjectProperty.FiniteProducts.0.CategoryTheory.ObjectProperty.prop_of_isLimit_fan.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {J : Type u_1} (motive : CategoryTheory.Discrete J → Prop) (h : CategoryTheory.Discrete J),
(∀ (j : J), motive { as := j }) → motive h |
Ordinal.enumOrdOrderIso | Mathlib.SetTheory.Ordinal.Enum | (s : Set Ordinal.{u_1}) → ¬BddAbove s → Ordinal.{u_1} ≃o ↑s |
Lean.Parser.Command.checkAssertions.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
DistribMulActionHom.instOneId | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] → {A : Type u_4} → [inst_1 : AddMonoid A] → [inst_2 : DistribMulAction M A] → One (A →+[M] A) |
Std.Internal.List.minEntry?_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l l' : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l → l.Perm l' → Std.Internal.List.minEntry? l = Std.Internal.List.minEntry? l' |
Lean.Parser.SyntaxStack.casesOn | Lean.Parser.Types | {motive : Lean.Parser.SyntaxStack → Sort u} →
(t : Lean.Parser.SyntaxStack) →
((raw : Array Lean.Syntax) → (drop : ℕ) → motive { raw := raw, drop := drop }) → motive t |
Equiv.Perm.sign_eq_prod_prod_Ioi | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} (σ : Equiv.Perm (Fin n)), Equiv.Perm.sign σ = ∏ i, ∏ j ∈ Finset.Ioi i, if σ i < σ j then 1 else -1 |
FormalMultilinearSeries.ofScalarsSum | Mathlib.Analysis.Analytic.OfScalars | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Field 𝕜] →
[inst_1 : Ring E] → [Algebra 𝕜 E] → [inst : TopologicalSpace E] → [IsTopologicalRing E] → (ℕ → 𝕜) → E → E |
FP.Float.inf.inj | Mathlib.Data.FP.Basic | ∀ {C : FP.FloatCfg} {a a_1 : Bool}, FP.Float.inf a = FP.Float.inf a_1 → a = a_1 |
_private.Mathlib.LinearAlgebra.Isomorphisms.0.LinearMap.quotientInfEquivSupQuotient_surjective._simp_1_2 | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) |
ProofWidgets.ExprPresenter | ProofWidgets.Presentation.Expr | Type |
CategoryTheory.Subobject.widePullbackι.eq_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.LocallySmall.{w, v₁, u₁} C]
[inst_2 : CategoryTheory.WellPowered.{w, v₁, u₁} C] [inst_3 : CategoryTheory.Limits.HasWidePullbacks C] {A : C}
(s : Set (CategoryTheory.Subobject A)),
CategoryTheory.Subobject.widePullbackι s = CategoryTheory.Limits.limit.π (CategoryTheory.Subobject.wideCospan s) none |
Prefunctor.map_reverse | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] [inst_2 : Quiver.HasReverse U]
[inst_3 : Quiver.HasReverse V] (φ : U ⥤q V) [φ.MapReverse] {u v : U} (e : u ⟶ v),
φ.map (Quiver.reverse e) = Quiver.reverse (φ.map e) |
MulActionSemiHomClass.rec | Mathlib.GroupTheory.GroupAction.Hom | {F : Type u_8} →
{M : Type u_9} →
{N : Type u_10} →
{φ : M → N} →
{X : Type u_11} →
{Y : Type u_12} →
[inst : SMul M X] →
[inst_1 : SMul N Y] →
[inst_2 : FunLike F X Y] →
{motive : MulActionSemiHomClass F φ X Y → Sort u} →
((map_smulₛₗ : ∀ (f : F) (c : M) (x : X), f (c • x) = φ c • f x) → motive ⋯) →
(t : MulActionSemiHomClass F φ X Y) → motive t |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_le_size._proof_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {t : Std.DTreeMap.Internal.Impl α fun x => β}, ¬t.size - 1 ≤ t.size + 1 → False |
Irrational.eventually_forall_le_dist_cast_rat_of_den_le | Mathlib.Topology.Instances.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (n : ℕ), ∀ᶠ (ε : ℝ) in nhds 0, ∀ (r : ℚ), r.den ≤ n → ε ≤ dist x ↑r |
CategoryTheory.Limits.ColimitPresentation.isColimit | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(self : CategoryTheory.Limits.ColimitPresentation J X) →
CategoryTheory.Limits.IsColimit { pt := X, ι := self.ι } |
Order.sub_one_wcovBy._simp_1 | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Sub α] [inst_2 : One α] [PredSubOrder α] (x : α), (x - 1 ⩿ x) = True |
tprod_setElem_eq_tprod_setElem_diff | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} (s t : Set β),
(∀ b ∈ t, f b = 1) → ∏' (a : ↑s), f ↑a = ∏' (a : ↑(s \ t)), f ↑a |
Lean.Diff.Histogram.Entry | Lean.Util.Diff | Type u → ℕ → ℕ → Type |
RelEmbedding.symm | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ↪r s) [Std.Symm s], Std.Symm r |
Rack.EnvelGroup | Mathlib.Algebra.Quandle | (R : Type u_1) → [Rack R] → Type u_1 |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instToJsonSemanticTokenModifier.toJson.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.SemanticTokenModifier → Sort u_1) →
(x : Lean.Lsp.SemanticTokenModifier) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.declaration) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.definition) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.readonly) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.static) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.deprecated) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.abstract) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.async) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.modification) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.documentation) →
(Unit → motive Lean.Lsp.SemanticTokenModifier.defaultLibrary) → motive x |
SSet.stdSimplex.const | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | (n : ℕ) → Fin (n + 1) → (m : SimplexCategoryᵒᵖ) → (SSet.stdSimplex.obj (SimplexCategory.mk n)).obj m |
UpperHalfPlane.instAddActionReal._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (x : ℝ) (z : UpperHalfPlane), 0 < (↑x + ↑z).im |
MeasureTheory.IsAddFundamentalDomain.mono | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ {ν : MeasureTheory.Measure α}, ν.AbsolutelyContinuous μ → MeasureTheory.IsAddFundamentalDomain G s ν |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
c.delete l = { clause := List.erase c.clause l, nodupkey := ⋯, nodup := ⋯ } |
CategoryTheory.Mon.braiding_hom_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.SymmetricCategory C] (M N : CategoryTheory.Mon C), (β_ M N).hom.hom = (β_ M.X N.X).hom |
CategoryTheory.BasedFunctor.w | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (self : CategoryTheory.BasedFunctor 𝒳 𝒴), self.comp 𝒴.p = 𝒳.p |
Equidecomp.refl | Mathlib.Algebra.Group.Action.Equidecomp | (X : Type u_1) → (G : Type u_2) → [inst : Monoid G] → [inst_1 : MulAction G X] → Equidecomp X G |
Std.HashMap.getElem!_ofList_of_mem | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
∀ {v : β} [inst : Inhabited β],
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (k, v) ∈ l → (Std.HashMap.ofList l)[k']! = v |
PrimeSpectrum.BasicConstructibleSetData.rec | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} →
{motive : PrimeSpectrum.BasicConstructibleSetData R → Sort u} →
((f : R) → (n : ℕ) → (g : Fin n → R) → motive { f := f, n := n, g := g }) →
(t : PrimeSpectrum.BasicConstructibleSetData R) → motive t |
Quot.lift.decidablePred | Mathlib.Data.Quot | {α : Sort u_1} →
(r : α → α → Prop) →
(f : α → Prop) → (h : ∀ (a b : α), r a b → f a = f b) → [hf : DecidablePred f] → DecidablePred (Quot.lift f h) |
SaturatedAddSubmonoid.ext_iff | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {s₁ s₂ : SaturatedAddSubmonoid M},
s₁ = s₂ ↔ s₁.toAddSubmonoid = s₂.toAddSubmonoid |
Lean.Meta.RecursorUnivLevelPos._sizeOf_inst | Lean.Meta.RecursorInfo | SizeOf Lean.Meta.RecursorUnivLevelPos |
Mathlib.Tactic.BicategoryLike.IsoLift._sizeOf_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.IsoLift → ℕ |
String.Slice.Pattern.Model.isMatch_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch pat pos ↔
String.Slice.Pattern.Model.ForwardPatternModel.Matches pat (s.sliceTo pos).copy |
Equiv.Perm.one_lt_card_support_of_ne_one | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α}, f ≠ 1 → 1 < f.support.card |
Representation.char_dual | Mathlib.RepresentationTheory.Character | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Group G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [FiniteDimensional k V] (ρ : Representation k G V) (g : G), ρ.dual.character g = ρ.character g⁻¹ |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.Subsemiring.prod_top._simp_1_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {s : Subsemiring R}
{t : Subsemiring S} {p : R × S}, (p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.ContinuousAlgEquiv.eq_continuousLinearEquivConjContinuousAlgEquiv._simp_1_17 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
{f g : M →ₛₗ[σ] M₃}, (f = g) = ∀ (x : M), f x = g x |
IsSimpleOrder.equivBool.congr_simp | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : DecidableEq α] [inst_1 : LE α] [inst_2 : BoundedOrder α] [inst_3 : IsSimpleOrder α],
IsSimpleOrder.equivBool = IsSimpleOrder.equivBool |
RatCast.mk._flat_ctor | Batteries.Classes.RatCast | {K : Type u} → (ℚ → K) → RatCast K |
SemiRingCat.instCategory._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {W X Y Z : SemiRingCat} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } |
Submodule.pointwiseNeg | Mathlib.Algebra.Module.Submodule.Pointwise | {R : Type u_2} →
{M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Neg (Submodule R M) |
_private.Lean.Elab.MacroRules.0.Lean.Elab.Command.elabMacroRulesAux.match_6 | Lean.Elab.MacroRules | (motive : Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") → Sort u_1) →
(attrs? : Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",")) →
((attrs : Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") → motive (some attrs)) →
(Unit → motive none) → motive attrs? |
_private.Mathlib.SetTheory.Lists.0.Lists'.ofList.match_1.eq_2 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (motive : List (Lists α) → Sort u_2) (a : Lists α) (l : List (Lists α)) (h_1 : Unit → motive [])
(h_2 : (a : Lists α) → (l : List (Lists α)) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l |
CategoryTheory.Equivalence.ctorIdx | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} → {inst_1 : CategoryTheory.Category.{v₂, u₂} D} → (C ≌ D) → ℕ |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.GenContFract.IntFractPair.exists_succ_nth_stream_of_fr_zero._simp_1_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
Nat.factoredNumbers.map_prime_pow_mul | Mathlib.NumberTheory.SmoothNumbers | ∀ {F : Type u_1} [inst : Mul F] {f : ℕ → F},
(∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) →
∀ {s : Finset ℕ} {p : ℕ},
Nat.Prime p → p ∉ s → ∀ (e : ℕ) {m : ↑(Nat.factoredNumbers s)}, f (p ^ e * ↑m) = f (p ^ e) * f ↑m |
MeasureTheory.ComplexMeasure.singularPart._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ContinuousAdd ℝ |
EquivLike.comp_surjective | Mathlib.Data.FunLike.Equiv | ∀ {F : Sort u_2} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike F β γ] (f : α → β) (e : F),
Function.Surjective (⇑e ∘ f) ↔ Function.Surjective f |
FiniteArchimedeanClass.closedBall | Mathlib.Algebra.Order.Module.Archimedean | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
(K : Type u_2) →
[inst_3 : Ring K] →
[inst_4 : LinearOrder K] →
[IsOrderedRing K] →
[Archimedean K] → [inst_7 : Module K M] → [PosSMulMono K M] → FiniteArchimedeanClass M → Submodule K M |
Submodule.piQuotientLift._proof_1 | Mathlib.LinearAlgebra.Quotient.Pi | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) |
Int.Linear.Expr.denote.eq_7 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (e : Int.Linear.Expr) (k : ℤ),
Int.Linear.Expr.denote ctx (e.mulR k) = Int.Linear.Expr.denote ctx e * k |
Batteries.Tactic.Lint.SimpTheoremInfo.noConfusionType | Batteries.Tactic.Lint.Simp | Sort u → Batteries.Tactic.Lint.SimpTheoremInfo → Batteries.Tactic.Lint.SimpTheoremInfo → Sort u |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.instBEqOp.beq | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op → Bool |
Lean.Grind.ToInt.Pow.toInt_pow | Init.Grind.ToInt | ∀ {α : Type u} {inst : HPow α ℕ α} {I : outParam Lean.Grind.IntInterval} {inst_1 : Lean.Grind.ToInt α I}
[self : Lean.Grind.ToInt.Pow α I] (x : α) (n : ℕ), ↑(x ^ n) = I.wrap (↑x ^ n) |
MvPolynomial.iterToSum_C_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R] (c : S₂),
(MvPolynomial.iterToSum R S₁ S₂) (MvPolynomial.C (MvPolynomial.X c)) = MvPolynomial.X (Sum.inr c) |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atBot_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g |
StarSubalgebra.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsTopologicalSemiring A] (s : StarSubalgebra R A), 0 ∈ s.topologicalClosure.carrier |
UInt64.toBitVec_eq_of_eq | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b → a.toBitVec = b.toBitVec |
Complex.exp_ne_zero._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), (Complex.exp x = 0) = False |
IsLocalExtr.deriv_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {f : ℝ → ℝ} {a : ℝ}, IsLocalExtr f a → deriv f a = 0 |
Function.HasTemperateGrowth.zero | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F], Function.HasTemperateGrowth fun x => 0 |
nhdsSet_Iic | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderClosedTopology α] {a : α},
nhdsSet (Set.Iic a) = nhds a ⊔ Filter.principal (Set.Iio a) |
QuaternionAlgebra.imJ | Mathlib.Algebra.Quaternion | {R : Type u_1} → {a b c : R} → QuaternionAlgebra R a b c → R |
Lean.Server.RequestHandler.mk.noConfusion | Lean.Server.Requests | {P : Sort u} →
{fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)} →
{fileSource' : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri} →
{handle' : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)} →
{ fileSource := fileSource, handle := handle } = { fileSource := fileSource', handle := handle' } →
(fileSource = fileSource' → handle = handle' → P) → P |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.LinearMap.isPositive_iff._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.notMem_nil.match_1_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (a : α) (motive : a ∈ Stream'.Seq.nil → Prop) (x : a ∈ Stream'.Seq.nil),
(∀ (w : ℕ) (h : some a = none), motive ⋯) → motive x |
Field.div._inherited_default | Mathlib.Algebra.Field.Defs | {K : Type u} →
(mul : K → K → K) →
(∀ (a b c : K), a * b * c = a * (b * c)) →
(one : K) →
(∀ (a : K), 1 * a = a) →
(∀ (a : K), a * 1 = a) →
(npow : ℕ → K → K) →
(∀ (x : K), npow 0 x = 1) → (∀ (n : ℕ) (x : K), npow (n + 1) x = npow n x * x) → (K → K) → K → K → K |
WeierstrassCurve.coeff_Φ | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℤ), (W.Φ n).coeff (n.natAbs ^ 2) = 1 |
_private.Lean.Level.0.Lean.Level.isIMax._sparseCasesOn_1.else_eq | Lean.Level | ∀ {motive : Lean.Level → Sort u} (t : Lean.Level) (imax : (a a_1 : Lean.Level) → motive (a.imax a_1))
(«else» : Nat.hasNotBit 8 t.ctorIdx → motive t) (h : Nat.hasNotBit 8 t.ctorIdx),
Lean.Level.isIMax._sparseCasesOn_1✝ t imax «else» = «else» h |
Set.SurjOn.image_invFunOn_image | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} [inst : Nonempty α],
Set.SurjOn f s t → f '' (Function.invFunOn f s '' t) = t |
Fin.appendIsometry._proof_2 | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] (m n : ℕ) (x x_1 : (Fin m → α) × (Fin n → α)),
edist ((Fin.appendEquiv m n).toFun x) ((Fin.appendEquiv m n).toFun x_1) = edist x x_1 |
Valuation.IsEquiv.of_eq | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] {v v' : Valuation R Γ₀},
v = v' → v.IsEquiv v' |
_private.Mathlib.Condensed.Light.InternallyProjective.0.LightCondensed.ihom_map_val_app._simp_1_2 | Mathlib.Condensed.Light.InternallyProjective | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {X : C} {Y Y' : D} (f : X ⟶ G.obj Y)
(g : Y ⟶ Y'),
CategoryTheory.CategoryStruct.comp ((adj.homEquiv X Y).symm f) g =
(adj.homEquiv X Y').symm (CategoryTheory.CategoryStruct.comp f (G.map g)) |
PowerSeries.IsWeierstrassDivisorAt.mod_coe_eq_self | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : PowerSeries A} {I : Ideal A} (H : g.IsWeierstrassDivisorAt I)
[inst_1 : IsAdicComplete I A] {r : Polynomial A},
r.degree < ↑((PowerSeries.map (Ideal.Quotient.mk I)) g).order.toNat → H.mod ↑r = r |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rcf : RingHomClass F R S] {f : F} {r : R}, (r ∈ RingHom.ker f) = (f r = 0) |
Lean.Expr.replaceNoCache._sunfold | Lean.Util.ReplaceExpr | (Lean.Expr → Option Lean.Expr) → Lean.Expr → Lean.Expr |
Array.setIfInBounds_def | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (xs : Array α) (i : ℕ) (a : α), xs.setIfInBounds i a = if h : i < xs.size then xs.set i a h else xs |
Lean.Parser.ParserCategory._sizeOf_1 | Lean.Parser.Basic | Lean.Parser.ParserCategory → ℕ |
SeparationQuotient.instAddCommSemigroup | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : AddCommSemigroup M] → [ContinuousAdd M] → AddCommSemigroup (SeparationQuotient M) |
CategoryTheory.Over.ConstructProducts.conesEquivFunctor.match_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {J : Type u_1} →
(motive : CategoryTheory.Discrete J → Sort u_2) →
(x : CategoryTheory.Discrete J) → ((j : J) → motive { as := j }) → motive x |
TensorProduct.toIntegralClosure_bijective_of_smooth | Mathlib.RingTheory.Smooth.IntegralClosure | ∀ {R : Type u_1} {S : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.Smooth R S],
Function.Bijective ⇑(TensorProduct.toIntegralClosure R S B) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.