name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R), CategoryTheory.IsCofilteredOrEmpty D | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore_length._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True | false |
ProbabilityTheory.geometricPMFReal | Mathlib.Probability.Distributions.Geometric | ℝ → ℕ → ℝ | true |
continuousAt_jacobiTheta₂ | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z : ℂ) {τ : ℂ}, 0 < τ.im → ContinuousAt (fun p => jacobiTheta₂ p.1 p.2) (z, τ) | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (x x_1 : (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ)
(x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.PreGaloisCategory.Poi... | false |
ComplexShape.down.congr_simp | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : Add α] [inst_1 : IsRightCancelAdd α] [inst_2 : One α],
ComplexShape.down α = ComplexShape.down α | true |
ImplicitFunctionData.hasStrictFDerivAt_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | true |
Array.back_scanl? | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {f : β → α → β} {as : Array α},
(Array.scanl f init as).back? = some (Array.foldl f init as) | true |
LieDerivation.mk.injEq | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(toLinearMap : L →ₗ[R] M) (leibniz' : ∀ (a b : L), toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, t... | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
Lean.Meta.LazyDiscrTree.Key.fvar.injEq | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.FVarId) (a_1 : ℕ) (a_2 : Lean.FVarId) (a_3 : ℕ),
(Lean.Meta.LazyDiscrTree.Key.fvar a a_1 = Lean.Meta.LazyDiscrTree.Key.fvar a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | true |
CategoryTheory.Limits.Fork.IsLimit.lift' | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{s : CategoryTheory.Limits.Fork f g} →
CategoryTheory.Limits.IsLimit s →
{W : C} →
(k : W ⟶ X) →
CategoryTheory.CategoryStruct.comp k f = CategoryTheory.Category... | true |
Polynomial.eval_mul_X_pow | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R} {k : ℕ},
Polynomial.eval x (p * Polynomial.X ^ k) = Polynomial.eval x p * x ^ k | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.hasDerivAt_taylorWithinEval_succ._simp_1_6 | Mathlib.Analysis.Calculus.Taylor | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Std.HashMap.get?_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α}, k ∉ m₁ → (m₁ ∪ m₂).get? k = m₂.get? k | true |
WeierstrassCurve.Projective.Nonsingular | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → Prop | true |
MeasurableSpace.DynkinSystem.mk.sizeOf_spec | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_4} [inst : SizeOf α] (Has : Set α → Prop) (has_empty : Has ∅) (has_compl : ∀ {a : Set α}, Has a → Has aᶜ)
(has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Function.onFun Disjoint f) → (∀ (i : ℕ), Has (f i)) → Has (⋃ i, f i)),
sizeOf { Has := Has, has_empty := has_empty, has_compl := has_compl, has_iUnio... | true |
RCLike.I_to_real | Mathlib.Analysis.RCLike.Basic | RCLike.I = 0 | true |
IsAddRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsCancelAdd R] (g : R), IsAddRegular g | true |
Int64.toISize_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int64.ofNat n).toISize = ISize.ofNat n | true |
AffineMap.instAddCommGroup._proof_4 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] (x : P1 →ᵃ[k] V2)
(x_1 : ℕ), ⇑(x_1 • x) = x_1 • ⇑x | false |
MeasureTheory.AEEqFun.instMonoid | Mathlib.MeasureTheory.Function.AEEqFun | {α : Type u_1} →
{γ : Type u_3} →
[inst : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_1 : TopologicalSpace γ] → [inst_2 : Monoid γ] → [ContinuousMul γ] → Monoid (α →ₘ[μ] γ) | true |
CommRingCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(s : CategoryTheory.Limits.Cocone F) → CommRingCat.Colimits.Prequotient F → ↑s.pt | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
l'.size ≤ d.size → d.size ≤ l'.size + 1 → ¬d.size + 1 + r'.size ≤ l'.size + 1 + r'.size + 1 → False | false |
ENat.iInf_toNat | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} {f : ι → ℕ}, (⨅ i, ↑(f i)).toNat = ⨅ i, f i | true |
Int.ModEq.mul_left | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (c : ℤ), a ≡ b [ZMOD n] → c * a ≡ c * b [ZMOD n] | true |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_three._simp_1_3 | Init.Data.ByteArray.Lemmas | ∀ {l l' : List UInt8}, l.toByteArray ++ l'.toByteArray = (l ++ l').toByteArray | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.toExpr.go._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr | false |
CategoryTheory.TwoSquare.mk | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | true |
Kronecker.«_aux_Mathlib_LinearAlgebra_Matrix_Kronecker___macroRules_Kronecker_term_⊗ₖₜ[_]__1» | Mathlib.LinearAlgebra.Matrix.Kronecker | Lean.Macro | false |
Topology.WithGeneratedByTopology.isClosed_iff | Mathlib.Topology.Convenient.GeneratedBy | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [tY : TopologicalSpace Y]
{U : Set (Topology.WithGeneratedByTopology X Y)},
IsClosed U ↔ ∀ ⦃i : ι⦄ (f : C(X i, Y)), IsClosed (⇑f ⁻¹' (⇑Topology.WithGeneratedByTopology.equiv.symm ⁻¹' U)) | true |
RootPairing.IsIrreducible.mk' | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] {K : Type u_5}
[inst_2 : Field K] [inst_3 : Module K M] [inst_4 : Module K N] [Nontrivial M] (P : RootPairing ι K M N),
(∀ (q : Submodule K M), (∀ (i : ι), q ∈ Module.End.invtSubmodule ↑(P.reflection i)) → q ≠ ⊥ → q = ⊤... | true |
BooleanSubalgebra.subtype_comp_inclusion | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L M : BooleanSubalgebra α} (h : L ≤ M),
M.subtype.comp (BooleanSubalgebra.inclusion h) = L.subtype | true |
FiniteIndexNormalAddSubgroup.rec | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
{motive : FiniteIndexNormalAddSubgroup G → Sort u} →
((toAddSubgroup : AddSubgroup G) →
(isNormal' : toAddSubgroup.Normal) →
(isFiniteIndex' : toAddSubgroup.FiniteIndex) →
motive { toAddSubgroup := toAddSubgroup, isNormal' := isNorma... | false |
_private.Mathlib.Topology.Order.0.TopologicalSpace.nhds_mkOfNhds_single._simp_1_2 | Mathlib.Topology.Order | ∀ {α : Type u_1} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) = p a | false |
continuousAt_gauge_zero | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} [inst_2 : TopologicalSpace E]
[ContinuousSMul ℝ E], s ∈ nhds 0 → ContinuousAt (gauge s) 0 | true |
CategoryTheory.SimplicialObject.IsCoskeletal.isRightKanExtension | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : CategoryTheory.SimplicialObject C} {n : ℕ}
[self : X.IsCoskeletal n],
CategoryTheory.Functor.IsRightKanExtension X
(CategoryTheory.CategoryStruct.id ((SimplexCategory.Truncated.inclusion n).op.comp X)) | true |
Lean.Meta.SimpAll.M | Lean.Meta.Tactic.Simp.SimpAll | Type → Type | true |
Differentiable.fun_add_iff_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f g : E → F},
Differentiable 𝕜 f → ((Differentiable 𝕜 fun i => f i + g i) ↔ Differentiable 𝕜 g) | true |
List.untrop_prod | Mathlib.Algebra.Tropical.BigOperators | ∀ {R : Type u_1} [inst : AddMonoid R] (l : List (Tropical R)), Tropical.untrop l.prod = (List.map Tropical.untrop l).sum | true |
MeasureTheory.llr.eq_1 | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) (x : α),
MeasureTheory.llr μ ν x = Real.log (μ.rnDeriv ν x).toReal | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_ultrafilter._simp_1_2 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
SemistandardYoungTableau.col_strict' | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (self : SemistandardYoungTableau μ) {i1 i2 j : ℕ},
i1 < i2 → (i2, j) ∈ μ → self.entry i1 j < self.entry i2 j | true |
FirstOrder.Language.instUniqueStructureEmpty | Mathlib.ModelTheory.Basic | {M : Type w} → Unique (FirstOrder.Language.empty.Structure M) | true |
CategoryTheory.SmallObject.SuccStruct.mk | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
C → (succ : C → C) → ((X : C) → X ⟶ succ X) → CategoryTheory.SmallObject.SuccStruct C | true |
ContinuousMonoidHom.comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
{C : Type u_4} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : Monoid C] →
[inst_3 : TopologicalSpace A] →
[inst_4 : TopologicalSpace B] → [inst_5 : TopologicalSpace C] → (B →ₜ* C) → (A →ₜ* B) → A →ₜ* C | true |
Lean.JsonRpc.Message.noConfusion | Lean.Data.JsonRpc | {P : Sort u} → {t t' : Lean.JsonRpc.Message} → t = t' → Lean.JsonRpc.Message.noConfusionType P t t' | false |
MvPolynomial.restrictSupportIdeal.congr_simp | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {σ : Type u} (R : Type v) [inst : CommSemiring R] (s s_1 : Set (σ →₀ ℕ)) (e_s : s = s_1) (hs : IsUpperSet s),
MvPolynomial.restrictSupportIdeal R s hs = MvPolynomial.restrictSupportIdeal R s_1 ⋯ | true |
UniformSpace.Completion.mapRingEquiv_symm_apply | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
{β : Type u} [inst_4 : UniformSpace β] [inst_5 : Ring β] [inst_6 : IsUniformAddGroup β] [inst_7 : IsTopologicalRing β]
(f : α ≃+* β) (hf : Continuous ⇑f) (hf' : Continuous ⇑f.symm) (a : UniformSp... | true |
Lean.Grind.Bool.or_eq_of_eq_true_left | Init.Grind.Lemmas | ∀ {a b : Bool}, a = true → (a || b) = true | true |
HilbertBasis.hasSum_repr_symm | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (b : HilbertBasis ι 𝕜 E) (f : ↥(lp (fun i => 𝕜) 2)),
HasSum (fun i => ↑f i • b i) (b.repr.symm f) | true |
AdjoinRoot.instCommRing._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R) (a b c : AdjoinRoot f), a + b + c = a + (b + c) | false |
Std.Format.MonadPrettyFormat.mk | Init.Data.Format.Basic | {m : Type → Type} →
(String → m Unit) → (ℕ → m Unit) → m ℕ → (ℕ → m Unit) → (ℕ → m Unit) → Std.Format.MonadPrettyFormat m | true |
Lean.ErrorExplanation.rec | Lean.ErrorExplanation | {motive : Lean.ErrorExplanation → Sort u} →
((doc : String) →
(metadata : Lean.ErrorExplanation.Metadata) →
(declLoc? : Option Lean.DeclarationLocation) →
motive { doc := doc, metadata := metadata, declLoc? := declLoc? }) →
(t : Lean.ErrorExplanation) → motive t | false |
Real.HolderTriple.pos' | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → 0 < r | true |
Algebra.PreSubmersivePresentation.differential._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u_1} {S : Type u_4} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ), SMulCommClass P.Ring P.Ring (σ → P.Ring) | false |
AddUnits.mk_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (u : AddUnits α) (y : α) (h₁ : ↑u + y = 0) (h₂ : y + ↑u = 0),
{ val := ↑u, neg := y, val_neg := h₁, neg_val := h₂ } = u | true |
Lean.Lsp.CompletionList.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionList → Sort u} →
(t : Lean.Lsp.CompletionList) →
((isIncomplete : Bool) →
(items : Array Lean.Lsp.CompletionItem) → motive { isIncomplete := isIncomplete, items := items }) →
motive t | false |
round.eq_1 | Mathlib.Algebra.Order.Round | ∀ {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] (x : α),
round x = if 2 * Int.fract x < 1 then ⌊x⌋ else ⌈x⌉ | true |
_private.Init.Data.SInt.Lemmas.0.Int16.toISize_ne_minValue._proof_1_2 | Init.Data.SInt.Lemmas | ∀ (a : Int16), -2 ^ 15 ≤ a.toInt → ISize.minValue.toInt ≤ -2 ^ 31 → a.toInt = ISize.minValue.toInt → False | false |
Nat.ToInt.of_eq | Init.Data.Int.OfNat | ∀ {a b : ℕ} {a' b' : ℤ}, ↑a = a' → ↑b = b' → a = b → a' = b' | true |
IsValuativeTopology.hasBasis_nhds_zero' | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R],
(nhds 0).HasBasis (fun x => x ≠ 0) fun x => {x_1 | (ValuativeRel.valuation R) x_1 < x} | true |
MeasureTheory.«_aux_Mathlib_MeasureTheory_OuterMeasure_AE___macroRules_MeasureTheory_term∀ᵐ_∂_,__1» | Mathlib.MeasureTheory.OuterMeasure.AE | Lean.Macro | false |
pinGroup.instStarMulSubtypeCliffordAlgebraMemSubmonoid._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star (star x) = x | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.OrderRel.ne | Mathlib.Tactic.Positivity.Core | Mathlib.Meta.Positivity.OrderRel✝ | true |
_private.Mathlib.NumberTheory.Multiplicity.0.Nat.eight_dvd_sq_sub_one_of_odd._proof_1_1 | Mathlib.NumberTheory.Multiplicity | ∀ (m : ℕ), (2 * m + 1) ^ 2 - 1 = 4 * (m * (m + 1)) | false |
Std.TreeMap.Raw.getElem_insertMany_list.match_1 | Std.Data.TreeMap.Raw.Lemmas | {β : Type u_1} →
(motive : Option β → Sort u_2) →
(x : Option β) → ((v : β) → x = some v → motive (some v)) → (x = none → motive none) → motive x | false |
WithLp.ofLp_multisetSum | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (V : Type u_4) [inst : AddCommGroup V] (s : Multiset (WithLp p V)),
s.sum.ofLp = (Multiset.map WithLp.ofLp s).sum | true |
AlgebraicGeometry.Scheme.kerFunctor._proof_4 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ (Y : AlgebraicGeometry.Scheme) {X Y_1 Z : (CategoryTheory.Over Y)ᵒᵖ} (x : X ⟶ Y_1) (x : Y_1 ⟶ Z),
AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop X).hom ≤ AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop Z).hom | false |
CategoryTheory.bifunctorComp₂₃FunctorObj_obj | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | true |
EuclideanDomain.toNontrivial | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [self : EuclideanDomain R], Nontrivial R | true |
BoxIntegral.TaggedPrepartition.noConfusionType | Mathlib.Analysis.BoxIntegral.Partition.Tagged | Sort u →
{ι : Type u_1} →
{I : BoxIntegral.Box ι} →
BoxIntegral.TaggedPrepartition I →
{ι' : Type u_1} → {I' : BoxIntegral.Box ι'} → BoxIntegral.TaggedPrepartition I' → Sort u | false |
ContinuousMap.instCompactSpaceElemCoeCompacts | Mathlib.Topology.ContinuousMap.Compact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (K : TopologicalSpace.Compacts X), CompactSpace ↑↑K | true |
FloatArray.instEmptyCollection | Init.Data.FloatArray.Basic | EmptyCollection FloatArray | true |
ProbabilityTheory.defaultRatCDF | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ℚ → ℝ | true |
Real.rpowIntegrand₀₁_eqOn_pow_div | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → Set.EqOn (fun x_1 => p.rpowIntegrand₀₁ x_1 x) (fun t => t ^ (p - 1) * x / (t + x)) (Set.Ioi 0) | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.IsLocalizedModule.instLiftOfLE._simp_3 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (r : R) (m : M) (s : ↥S),
r • IsLocalizedModule.mk' f m s = IsLocalizedMod... | false |
List.attach_filterMap | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → Option β},
(List.filterMap f l).attach =
List.filterMap
(fun x =>
match x with
| ⟨x, h⟩ => (f x).pbind fun b m => some ⟨b, ⋯⟩)
l.attach | true |
UniformContinuousConstVAdd.uniformContinuous_const_vadd | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} {inst : UniformSpace X} {inst_1 : VAdd M X} [self : UniformContinuousConstVAdd M X] (c : M),
UniformContinuous fun x => c +ᵥ x | true |
Batteries.RBNode.upperBound? | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → Ordering) → Batteries.RBNode α → optParam (Option α) none → Option α | true |
WithTop.mul_eq_top_iff | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {a b : WithTop α},
a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0 | true |
CategoryTheory.Presieve.singleton.rec | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : ⦃Y_1 : C⦄ → (a : Y_1 ⟶ X) → CategoryTheory.Presieve.singleton f a → Sort u} →
motive f ⋯ → ⦃Y_1 : C⦄ → {a : Y_1 ⟶ X} → (t : CategoryTheory.Presieve.singleton f a) → motive a t | false |
Submonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{g : M →* P} →
{T : Submonoid P} →
(∀ (y ... | true |
Lean.Meta.Grind.Arith.Linear.Case.fvarId | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | Lean.Meta.Grind.Arith.Linear.Case → Lean.FVarId | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unsafe_rec | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(state : Std.Sat.AIG.toCNF.State✝ aig) → { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state out upper h } | false |
AlgebraicGeometry.IsAffineOpen.isoSpec_hom | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U), hU.isoSpec.hom = U.toSpecΓ | true |
CategoryTheory.Comma.mapLeftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ : CategoryTheory.Functor A T} → ... | true |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_10 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J),
CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁ →
∀ (l : List J),
(∀ a ∈ l, CategoryTheory.Zigzag a j₂) → -1 * ↑(j₁ :: l).length + 1 ≤ 0 → (j₁ :: l).length - 1 < (j₁ :: l).length | false |
TopModuleCat.instIsRightAdjointTopCatForget₂ContinuousLinearMapIdCarrierContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) TopCat).IsRightAdjoint | true |
Complex.UnitDisc | Mathlib.Analysis.Complex.UnitDisc.Basic | Type | true |
CochainComplex.HomComplex.Cochain.rightShift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | IsRightCancelAdd ℤ | false |
Lean.Meta.Grind.TopSort.State.recOn | Lean.Meta.Tactic.Grind.EqResolution | {motive : Lean.Meta.Grind.TopSort.State → Sort u} →
(t : Lean.Meta.Grind.TopSort.State) →
((tempMark permMark : Std.HashSet Lean.Expr) →
(result : Array Lean.Expr) → motive { tempMark := tempMark, permMark := permMark, result := result }) →
motive t | false |
cfc_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
Std.Packages.LinearPreorderOfLEArgs.rec | Init.Data.Order.PackageFactories | {α : Type u} →
{motive : Std.Packages.LinearPreorderOfLEArgs α → Sort u_1} →
((toPreorderOfLEArgs : Std.Packages.PreorderOfLEArgs α) →
(ord :
let this := toPreorderOfLEArgs.le;
let this := toPreorderOfLEArgs.decidableLE;
Ord α) →
(le_total : ∀ (a b : α), a ≤ b... | false |
ENNReal.mul_div_cancel_right | Mathlib.Data.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → a * b / b = a | true |
Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letDecl.parenthesizer_137 | Lean.Parser.Term | IO Unit | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getEntryD.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (fallback : (a : α) × β a)
(x : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.getEntryD a fallback x =
match x with
| Std.DHashMap.Internal.AssocList.nil => fallback
| Std.DHashMap.Internal.AssocList.cons k v es =>
if (... | true |
Lean.Lsp.DidSaveTextDocumentParams.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidSaveTextDocumentParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(text? : Option String) → motive { textDocument := textDocument, text? := text? }) →
(t : Lean.Lsp.DidSaveTextDocumentParams) → motive t | false |
Set.swap_mem_addAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMagma α] {s t : Set α} {a : α} {x : α × α},
x.swap ∈ s.addAntidiagonal t a ↔ x ∈ t.addAntidiagonal s a | true |
Polynomial.coeff_comp_degree_mul_degree | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
q.natDegree ≠ 0 → (p.comp q).coeff (p.natDegree * q.natDegree) = p.leadingCoeff * q.leadingCoeff ^ p.natDegree | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.