name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.ObjectProperty.Basic.0.CategoryTheory.ObjectProperty.strictMap_ofObj._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C) (Y : C),
CategoryTheory.ObjectProperty.ofObj X Y = ∃ i, X i = Y | null | false |
Function.support_pow' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MonoidWithZero M₀] [IsReduced M₀] {n : ℕ} (f : ι → M₀),
n ≠ 0 → Function.support (f ^ n) = Function.support f | null | true |
CategoryTheory.isRegularMono_unop_iff_isRegularEpi | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.IsRegularMono f.unop ↔ CategoryTheory.IsRegularEpi f | null | true |
_private.Mathlib.Algebra.Lie.CartanSubalgebra.0.LieIdeal.normalizer_eq_top._simp_1_1 | Mathlib.Algebra.Lie.CartanSubalgebra | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (x : L), (x ∈ H.normalizer) = ∀ y ∈ H, ⁅x, y⁆ ∈ H | null | false |
Polynomial.sturmSeq._unary.eq_def | Mathlib.Algebra.Polynomial.Sturm.Sequence | ∀ {K : Type u_1} [inst : Field K] [inst_1 : DecidableEq K] (_x : (_ : Polynomial K) ×' Polynomial K),
Polynomial.sturmSeq._unary _x =
PSigma.casesOn _x fun p q => if p = 0 then [] else p :: Polynomial.sturmSeq._unary ⟨q, -p % q⟩ | null | false |
_private.Lean.Elab.Do.Switch.0.Lean.Elab.Term.expandTermUnless._regBuiltin.Lean.Elab.Term.expandTermUnless_1 | Lean.Elab.Do.Switch | IO Unit | null | false |
ZMod.LFunction_residue_one | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] (Φ : ZMod N → ℂ),
Filter.Tendsto (fun s => (s - 1) * ZMod.LFunction Φ s) (nhdsWithin 1 {1}ᶜ) (nhds (∑ j, Φ j / ↑N)) | The L-function of `Φ` has a residue at `s = 1` equal to the average value of `Φ`. | true |
USize.ofNat_add | Init.Data.UInt.Lemmas | ∀ (a b : ℕ), USize.ofNat (a + b) = USize.ofNat a + USize.ofNat b | null | true |
NonUnitalStarAlgebra.mem_top | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] {x : A}, x ∈ ⊤ | null | true |
_private.Init.Data.Array.Bootstrap.0.Array.toListImpl.eq_1 | Init.Data.Array.Bootstrap | ∀ {α : Type u} (as : Array α), as.toListImpl = Array.foldr List.cons [] as | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.collectType.match_1 | Lean.Compiler.LCNF.Basic | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.la... | null | false |
Lean.Widget.InteractiveTermGoal.noConfusion | Lean.Widget.InteractiveGoal | {P : Sort u} →
{t t' : Lean.Widget.InteractiveTermGoal} → t = t' → Lean.Widget.InteractiveTermGoal.noConfusionType P t t' | null | false |
Homeomorph.subtype._proof_2 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {p : X → Prop} {q : Y → Prop}
(h : X ≃ₜ Y) (h_iff : ∀ (x : X), p x ↔ q (h x)), Continuous (h.subtypeEquiv h_iff).invFun | null | false |
Fin.sum_eq_sum_map_finRange | Batteries.Data.Fin.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α] [inst_1 : Add α] (x : Fin n → α),
Fin.sum x = (List.map x (List.finRange n)).sum | null | true |
Set.toFinset_Iic | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α) [inst_2 : Fintype ↑(Set.Iic a)],
(Set.Iic a).toFinset = Finset.Iic a | null | true |
SSet.isColimitCokernelCoforkChainComplexDOneZero._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.HomologyZero | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X : SSet) (R : C),
CategoryTheory.CategoryStruct.comp ((X.chainComplex R).d 1 0) (SSet.π₀.fromChainComplexXZero X R) = 0 | null | false |
HomologicalComplex.instHasMapProdObjGradedObjectFunctorMapBifunctorXMapBifunctorMapObjπ | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {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_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
Filter.liminf_le_liminf._auto_3 | Mathlib.Order.LiminfLimsup | Lean.Syntax | null | false |
isPiSystem_Ico | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {ι : Sort u_3} {ι' : Sort u_4} [inst : LinearOrder α] (f : ι → α) (g : ι' → α),
IsPiSystem {S | ∃ i j, f i < g j ∧ Set.Ico (f i) (g j) = S} | null | true |
Subalgebra.involutiveStar._proof_4 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : StarRing A] (S : Subalgebra R A) {x y : A}, x ∈ star S.carrier → y ∈ star S.carrier → x + y ∈ star S.carrier | null | false |
Metric.isOpen_eball | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} {x : α} [inst : PseudoEMetricSpace α] {r : ENNReal}, IsOpen (Metric.eball x r) | null | true |
Nat.modEq_zero_iff | Mathlib.Data.Nat.ModEq | ∀ {a b : ℕ}, a ≡ b [MOD 0] ↔ a = b | null | true |
MeasureTheory.setLIntegral_condLExp | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {Ω : Type u_1} {mΩ₀ mΩ : MeasurableSpace Ω} (hm : mΩ ≤ mΩ₀) (P : MeasureTheory.Measure Ω)
[hσ : MeasureTheory.SigmaFinite (P.trim hm)] (X : Ω → ENNReal) {s : Set Ω},
MeasurableSet s → ∫⁻ (ω : Ω) in s, P⁻[X | mΩ] ω ∂P = ∫⁻ (ω : Ω) in s, X ω ∂P | The (Lebesgue) integral of the conditional (Lebesgue) expectation `P⁻[X|mΩ]` over an
`mΩ`-measurable set is equal to the integral of `X` on that set. | true |
Filter.Tendsto.eventuallyLE_one_mul_atBot | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] [inst_1 : Preorder M] [IsOrderedMonoid M] {l : Filter α}
{f g : α → M}, f ≤ᶠ[l] 1 → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x * g x) l Filter.atBot | null | true |
Ordset.nil._proof_1 | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α], Ordnode.Valid' ⊥ Ordnode.nil ⊤ | null | false |
ProbabilityTheory.covariance_mul_const_left | Mathlib.Probability.Moments.Covariance | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {X Y : Ω → ℝ} {μ : MeasureTheory.Measure Ω} (c : ℝ),
ProbabilityTheory.covariance (fun ω => X ω * c) Y μ = ProbabilityTheory.covariance X Y μ * c | null | true |
ZMod.repr._aux_1 | Mathlib.Data.ZMod.Defs | ZMod 0 → ℕ → Std.Format | null | false |
Finset.val_le_iff | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, s₁.val ≤ s₂.val ↔ s₁ ⊆ s₂ | null | true |
RatFunc.algebraMap_apply | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K] {R : Type u_1} [inst_2 : CommSemiring R]
[inst_3 : Algebra R (Polynomial K)] (x : R),
(algebraMap R (RatFunc K)) x =
(algebraMap (Polynomial K) (RatFunc K)) ((algebraMap R (Polynomial K)) x) /
(algebraMap (Polynomial K) (RatFunc K)) 1 | null | true |
List.IsPrefix.le_countP | Init.Data.List.Nat.Count | ∀ {α : Type u_1} {l₁ l₂ : List α} {p : α → Bool},
l₁ <+: l₂ → List.countP p l₂ - (l₂.length - l₁.length) ≤ List.countP p l₁ | null | true |
Int64.toBitVec_toInt16 | Init.Data.SInt.Lemmas | ∀ (x : Int64), x.toInt16.toBitVec = BitVec.signExtend 16 x.toBitVec | null | true |
setOf_isOpen_sSup | Mathlib.Topology.Order | ∀ {α : Type u} {T : Set (TopologicalSpace α)}, {s | IsOpen s} = ⋂ t ∈ T, {s | IsOpen s} | **Alias** of `setOfPred_isOpen_sSup`. | true |
MeasureTheory.lintegral_iInf' | Mathlib.MeasureTheory.Integral.Lebesgue.Sub | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {f : ℕ → α → ENNReal},
(∀ (n : ℕ), AEMeasurable (f n) μ) →
(∀ᵐ (a : α) ∂μ, Antitone fun i => f i a) →
∫⁻ (a : α), f 0 a ∂μ ≠ ⊤ → ∫⁻ (a : α), ⨅ n, f n a ∂μ = ⨅ n, ∫⁻ (a : α), f n a ∂μ | null | true |
SimpleGraph.finsubgraphHomFunctor._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {W : Type u_2} (G : SimpleGraph V) (F : SimpleGraph W) (X : G.Finsubgraphᵒᵖ),
(TypeCat.ofHom fun f => SimpleGraph.FinsubgraphHom.restrict ⋯ f) =
CategoryTheory.CategoryStruct.id (SimpleGraph.FinsubgraphHom (Opposite.unop X) F) | null | false |
_private.Mathlib.LinearAlgebra.LinearDisjoint.0.Submodule.LinearDisjoint.of_basis_right'._simp_1_2 | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N ≃ₗ[R] P), LinearMap.lTensor M ↑f = ↑(LinearEquiv.lTensor M f) | null | false |
CategoryTheory.Limits.IsColimit.precomposeInvEquiv | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F G : CategoryTheory.Functor J C} →
(α : F ≅ G) →
(c : CategoryTheory.Limits.Cocone F) →
CategoryTheory.Limits.IsColimit ((CategoryTheory... | A cocone precomposed with the inverse of a natural isomorphism is a colimit cocone
if and only if the original cocone is.
| true |
NumberField.house.basis_repr_norm_le_const_mul_house | Mathlib.NumberTheory.NumberField.House | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] [inst_2 : DecidableEq (K →+* ℂ)]
(α : NumberField.RingOfIntegers K) (i : K →+* ℂ),
‖↑((((NumberField.integralBasis K).reindex (NumberField.equivReindex K).symm).repr ↑α) i)‖ ≤
NumberField.house.c✝ K * NumberField.house ((algebraMap (NumberField.RingOfIn... | null | true |
List.getD_set_perm_cons | Batteries.Data.List.Perm | ∀ {α : Type u_1} (xs : List α) (i : ℕ) (v : α), (xs[i]?.getD v :: xs.set i v).Perm (v :: xs) | null | true |
CategoryTheory.ProjectiveResolution.Hom.ctorIdx | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{Z : C} →
{P : CategoryTheory.ProjectiveResolution Z} →
{Z' : C} → {P' : CategoryTheory.ProjectiveResolution Z'} →... | null | false |
ComplexShape.EulerCharSigns.rec | Mathlib.Algebra.Homology.EulerCharacteristic | {ι : Type u_1} →
{c : ComplexShape ι} →
{motive : c.EulerCharSigns → Sort u} →
((χ : ι → ℤˣ) → (χ_next : ∀ {i j : ι}, c.Rel i j → χ j = -χ i) → motive { χ := χ, χ_next := χ_next }) →
(t : c.EulerCharSigns) → motive t | null | false |
List.span_eq_takeWhile_dropWhile | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (l : List α), List.span p l = (List.takeWhile p l, List.dropWhile p l) | null | true |
AlgebraicGeometry.Scheme.Opens.nonempty_iff | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens), Nonempty ↥↑U ↔ (↑U).Nonempty | null | true |
_private.Mathlib.Algebra.Order.Module.Field.0.Mathlib.Meta.Positivity.evalSMul._sparseCasesOn_3 | Mathlib.Algebra.Order.Module.Field | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{e : Q(«$α»)} →
{motive : (a : Option Q(PartialOrder «$α»)) → Mathlib.Meta.Positivity.Strictness zα e a → Sort u} →
{a : Option Q(PartialOrder «$α»)} →
(t : Mathlib.Meta.Positivity.Strictness zα e a) →
({p... | null | false |
AddSubgroup.sSup_normal | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (Hs : Set (AddSubgroup G)), (∀ H ∈ Hs, H.Normal) → (sSup Hs).Normal | null | true |
Lean.getBoolOption | Lean.Data.Options | {m : Type → Type} → [Monad m] → [Lean.MonadOptions m] → Lean.Name → optParam Bool false → m Bool | null | true |
DFinsupp.instPreorder._proof_3 | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
(x x_1 x_2 : Π₀ (i : ι), α i), x ≤ x_1 → x_1 ≤ x_2 → ∀ (i : ι), x i ≤ x_2 i | null | false |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.fac | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A}
(hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.mu... | null | true |
Std.IO.Process.getCwd | Std.Async.Process | IO System.FilePath | Gets the current working directory.
| true |
Lean.FuzzyMatching.CharType.ctorIdx | Lean.Data.FuzzyMatching | Lean.FuzzyMatching.CharType → ℕ | null | false |
Lean.Elab.Tactic.Omega.groundInt?._unsafe_rec | Lean.Elab.Tactic.Omega.OmegaM | Lean.Expr → Option ℤ | null | false |
Matrix.Hessenberg.Similarity.charpoly_eq | Mathlib.LinearAlgebra.Matrix.Hessenberg.Similarity | ∀ {m : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : Fintype m] [inst_2 : DecidableEq m]
[inst_3 : LinearOrder m] [inst_4 : SuccOrder m] [IsDomain R] {A : Matrix m m R}
(cert : Matrix.Hessenberg.Similarity A), cert.H.charpoly = A.charpoly | null | true |
_private.Mathlib.Tactic.Echelon.Cert.0.Mathlib.Tactic.Echelon.certifyPivotedList._proof_1 | Mathlib.Tactic.Echelon.Cert | ∀ {u : Lean.Level} {n : ℕ} {α : Q(Type u)} (zα : Q(Zero «$α»)) (rows : Q(List (List «$α»))),
«$rows» =Q List.map (fun x => List.replicate «$n» 0) «$rows» | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.Fractions.0.DerivedCategory.right_fac.match_1_1 | Mathlib.Algebra.Homology.DerivedCategory.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {X Y : CochainComplex C ℤ} (f : DerivedCategory.Q.obj X ⟶ DerivedCategory.Q.obj Y)
(motive :
(∃ φ,
CategoryTheory.CategoryStruct.comp ((DerivedCategory.quotientCompQhIso C).... | null | false |
_private.Mathlib.Data.Set.Lattice.Bounded.0.Set.directedOn_iUnion._simp_1_2 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | null | false |
IsBoundedLinearMap.smul | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F] {f : E → F} {𝕜' : Type u_5} (c : 𝕜')
[inst_5 : SeminormedRing 𝕜'] [inst_6 : Module 𝕜' F] [IsBoundedSMul 𝕜' F] [SMulCommClass... | null | true |
String.Pos.lt_of_le_of_ne | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, p ≤ q → p ≠ q → p < q | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Spectrum.0.LinearMap.IsSymmetric.toMatrix_eigenvectorBasis._proof_1_3 | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] {n : ℕ} (hT : T.IsSymmetric) (hn : Module.finrank 𝕜 E = n)
(i j : Fin n),
(if i = j then (algebraMap ℝ 𝕜) (hT.eigenvalues hn j) else 0) =
i... | null | false |
derivedSeries_one | Mathlib.GroupTheory.Solvable | ∀ (G : Type u_1) [inst : Group G], derivedSeries G 1 = commutator G | null | true |
precArg | Init.Notation | Lean.ParserDescr | Precedence used for application arguments (`do`, `by`, ...). | true |
CategoryTheory.monoidOfSkeletalMonoidal._proof_2 | Mathlib.CategoryTheory.Monoidal.Skeleton | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(hC : CategoryTheory.Skeletal C) (n : ℕ) (x : C), x ^ (n + 1) = x ^ n * x | null | false |
Std.TreeSet.min!_le_min!_erase | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → (cmp t.min! (t.erase k).min!).isLE = true | null | true |
NonemptyInterval.map | Mathlib.Order.Interval.Basic | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → NonemptyInterval α → NonemptyInterval β | Pushforward of nonempty intervals. | true |
Manifold.«termMDiffAt[_]__» | Mathlib.Geometry.Manifold.Notation | Lean.ParserDescr | `MDiffAt[s] f x` elaborates to `MDifferentiableWithinAt I J f s x`,
trying to determine `I` and `J` from the local context.
The argument `x` can be omitted. | true |
_private.Lean.Elab.DocString.0.Lean.Doc.elabInline.match_1 | Lean.Elab.DocString | (motive : Lean.Exception → Sort u_1) →
(x : Lean.Exception) →
((e : Lean.Exception) →
(id : Lean.InternalExceptionId) →
(extra : Lean.KVMap) →
(h : e = Lean.Exception.internal id extra) → motive (namedPattern e (Lean.Exception.internal id extra) h)) →
((e : Lean.Exception) → mo... | null | false |
LinearMap.IsProj.submodule_unique | Mathlib.LinearAlgebra.Projection | ∀ {S : Type u_5} [inst : Semiring S] {M : Type u_6} [inst_1 : AddCommMonoid M] [inst_2 : Module S M] {f : M →ₗ[S] M}
{m₁ m₂ : Submodule S M}, LinearMap.IsProj m₁ f → LinearMap.IsProj m₂ f → m₁ = m₂ | null | true |
Lean.Elab.Level.State.noConfusion | Lean.Elab.Level | {P : Sort u} → {t t' : Lean.Elab.Level.State} → t = t' → Lean.Elab.Level.State.noConfusionType P t t' | null | false |
Lean.Compiler.LCNF.Alt.brecOn_2.go | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive_1 : Lean.Compiler.LCNF.Alt pu → Sort u} →
{motive_2 : Lean.Compiler.LCNF.FunDecl pu → Sort u} →
{motive_3 : Lean.Compiler.LCNF.Cases pu → Sort u} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
{motive_5 : Array (Lean.Compiler.LCNF.Alt pu) → ... | null | true |
List.Vector.inductionOn₃ | Mathlib.Data.Vector.Basic | {α : Type u_1} →
{n : ℕ} →
{β : Type u_6} →
{γ : Type u_7} →
{C : {n : ℕ} → List.Vector α n → List.Vector β n → List.Vector γ n → Sort u_8} →
(u : List.Vector α n) →
(v : List.Vector β n) →
(w : List.Vector γ n) →
C List.Vector.nil List.Vector.nil ... | Define `C u v w` by induction on a triplet of vectors
`u : Vector α n`, `v : Vector β n`, and `w : Vector γ b`. | true |
CategoryTheory.GrothendieckTopology.CoversTop.sections_ext | Mathlib.CategoryTheory.Sites.CoversTop.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {I : Type u_1}
{Y : I → C},
J.CoversTop Y →
∀ (F : CategoryTheory.Sheaf J (Type u_2)) {x y : ↑F.obj.sections},
(∀ (i : I), ↑x (Opposite.op (Y i)) = ↑y (Opposite.op (Y i))) → x = y | null | true |
Aesop.Strategy.breadthFirst | Aesop.Options.Public | Aesop.Strategy | Breadth-first search. Aesop always works on the oldest unsolved goal. Goal and
rule priorities are ignored, except to decide which rule is applied first.
| true |
MeasureTheory.setLIntegral_le_lintegral | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (f : α → ENNReal),
∫⁻ (x : α) in s, f x ∂μ ≤ ∫⁻ (x : α), f x ∂μ | null | true |
FirstOrder.Language.Term.relabelEquiv._proof_1 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_2} {β : Type u_4} (g : α ≃ β) (t : L.Term α),
FirstOrder.Language.Term.relabel (⇑g.symm) (FirstOrder.Language.Term.relabel (⇑g) t) = t | null | false |
SequentiallyComplete.setSeq_prod_subset | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] {f : Filter α} (hf : Cauchy f) {U : ℕ → SetRel α α}
(U_mem : ∀ (n : ℕ), U n ∈ uniformity α) {N m n : ℕ},
N ≤ m → N ≤ n → SequentiallyComplete.setSeq hf U_mem m ×ˢ SequentiallyComplete.setSeq hf U_mem n ⊆ U N | null | true |
IsFreeGroupoid.noConfusionType | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | Sort u →
{G : Type u_1} →
[inst : CategoryTheory.Groupoid G] →
IsFreeGroupoid G → {G' : Type u_1} → [inst' : CategoryTheory.Groupoid G'] → IsFreeGroupoid G' → Sort u | null | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex_ι | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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 l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
ContinuousLinearEquiv.compactConvergenceCLMCongrSL | Mathlib.Topology.Algebra.Module.Spaces.CompactConvergenceCLM | {𝕜 : Type u_7} →
{𝕜₂ : Type u_8} →
{𝕜₃ : Type u_9} →
{𝕜₄ : Type u_10} →
{E : Type u_11} →
{F : Type u_12} →
{G : Type u_13} →
{H : Type u_14} →
[inst : AddCommGroup E] →
[inst_1 : AddCommGroup F] →
[inst_2 ... | A pair of continuous (semi)linear equivalences generates a (semi)linear equivalence between the
spaces of continuous (semi)linear maps. This version is for the type alias
`CompactConvergenceCLM`. | true |
ModuleCat.Hom.hom₂ | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u_1} → [inst : CommRing R] → {M N P : ModuleCat R} → (M ⟶ ↧(N ⟶ P)) → ↑M →ₗ[R] ↑N →ₗ[R] ↑P | Turn a homomorphism into a bilinear map. | true |
FreeAbelianGroup.ring._proof_9 | Mathlib.GroupTheory.FreeAbelianGroup | ∀ (α : Type u_1) (a b : FreeAbelianGroup α), a + b = b + a | null | false |
Ideal.map_primeCompl_comap_of_surjective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S],
Function.Surjective ⇑f →
∀ (p : Ideal S) [inst_4 : p.IsPrime], Submonoid.map f (Ideal.comap f p).primeCompl = p.primeCompl | null | true |
Finset.sum_pos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M] {f : ι → M}
{s : Finset ι} [AddLeftStrictMono M], (∀ i ∈ s, 0 < f i) → s.Nonempty → 0 < ∑ i ∈ s, f i | null | true |
Polynomial.cyclotomic'.eq_1 | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (R : Type u_2) [inst : CommRing R] [inst_1 : IsDomain R],
Polynomial.cyclotomic' n R = ∏ μ ∈ primitiveRoots n R, (Polynomial.X - Polynomial.C μ) | null | true |
iteratedDerivWithin_fun_neg | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜} {s : Set 𝕜} (f : 𝕜 → F),
iteratedDerivWithin n (fun z => -f z) s x = -iteratedDerivWithin n f s x | null | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.mem_insert_self._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
LieAlgebra.SemiDirectSum.add_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x y : K ⋊⁅ψ⁆ L),
x + y = { left := x.left + y.left, right := x.right + y.right } | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.flattenList.toNatAux.match_1 | Init.Data.BitVec.Lemmas | {n : ℕ} →
(motive : List (BitVec n) → Sort u_1) →
(x : List (BitVec n)) →
(Unit → motive []) →
((x : BitVec n) → motive [x]) →
((x y : BitVec n) → (rest : List (BitVec n)) → motive (x :: y :: rest)) → motive x | null | false |
Topology.IsClosedEmbedding.measurable | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ] [BorelSpace γ] {f : α → γ},
Topology.IsClosedEmbedding f → Measurable f | null | true |
cfc_comp_smul | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
CategoryTheory.Functor.leftDerivedZeroIsoSelf_hom | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
[inst_6 : Cate... | null | true |
_private.Mathlib.Topology.Algebra.ProperAction.CompactlyGenerated.0.MulAction.properSMul_iff_isCompact_setOfPred_inter_nonempty.match_1_3 | Mathlib.Topology.Algebra.ProperAction.CompactlyGenerated | ∀ {G : Type u_1} {X : Type u_2} [inst : Group G] [inst_1 : MulAction G X] (U V : Set X)
(motive : (x : G × X) → x ∈ (fun gx => (gx.1 • gx.2, gx.2)) ⁻¹' U ×ˢ V → Prop) (x : G × X)
(x_1 : x ∈ (fun gx => (gx.1 • gx.2, gx.2)) ⁻¹' U ×ˢ V),
(∀ (g : G) (x : X) (x_2 : (g, x) ∈ (fun gx => (gx.1 • gx.2, gx.2)) ⁻¹' U ×ˢ V),... | null | false |
BitVec.ctz.eq_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w), x.ctz = x.reverse.clz | null | true |
Aesop.Substitution.instHashable | Aesop.Forward.Substitution | Hashable Aesop.Substitution | null | true |
CategoryTheory.Presheaf.IsLocallySurjective.rec | Mathlib.CategoryTheory.Sites.LocallySurjective | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{FA : A → A → Type u_1} →
{CA : A → Type w'} →
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (C... | null | false |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup.0.pinGroup.star_mem._simp_1_2 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N}, (y ∈ Submonoid.map f S) = ∃ x ∈ S, f x = y | null | false |
IsVAddApply.casesOn | Mathlib.Algebra.Group.IsApply | {M : Type u_1} →
{F : Type u_2} →
{α : Type u_3} →
{β : Type u_4} →
[inst : FunLike F α β] →
[inst_1 : VAdd M β] →
[inst_2 : VAdd M F] →
{motive : IsVAddApply M F α β → Sort u} →
(t : IsVAddApply M F α β) →
((vadd_apply : ∀ (f : F... | null | false |
Subgroup.comap_inclusion_subgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {K₁ K₂ : Subgroup G} (h : K₁ ≤ K₂) (H : Subgroup G),
Subgroup.comap (Subgroup.inclusion h) (H.subgroupOf K₂) = H.subgroupOf K₁ | null | true |
LieModule.isNilpotent_toEnd_sub_algebraMap | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u_2} {L : Type u_3} (M : Type u_4) [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]
[inst_7 : LieRing.IsNilpotent L] [IsNoetherian R M] (χ : L → R) (x : L),
IsNilpotent
((LieMo... | null | true |
ContMDiffAt.mfderiv_const | Mathlib.Geometry.Manifold.ContMDiffMFDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {m n : WithTop ℕ∞} {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [ins... | The derivative `D_yf(y)` is `C^m` at `x₀`, where the derivative is taken as a continuous
linear map. We have to assume that `f` is `C^n` at `x₀` for some `n ≥ m + 1`.
We have to insert a coordinate change from `x₀` to `x` to make the derivative sensible.
This is a special case of `ContMDiffAt.mfderiv` where `f` does no... | true |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.bv | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | (self : Std.Tactic.BVDecide.BVExpr.PackedBitVec) → BitVec self.w | null | true |
Nat.Partrec.Code.encode_lt_rfind' | Mathlib.Computability.PartrecCode | ∀ (cf : Nat.Partrec.Code), Encodable.encode cf < Encodable.encode cf.rfind' | null | true |
HahnSeries.SummableFamily.coeff_hsum_eq_sum | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} {α : Type u_5} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R]
{s : HahnSeries.SummableFamily Γ R α} {g : Γ}, s.hsum.coeff g = ∑ i ∈ (s.coeff g).support, (s i).coeff g | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.