name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.eLpNormEssSup_const_smul_le' | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_3} [inst : NormedRing 𝕜]
{ε : Type u_4} [inst_1 : TopologicalSpace ε] [inst_2 : ESeminormedAddMonoid ε] [inst_3 : SMul 𝕜 ε]
[ENormSMulClass 𝕜 ε] {c : 𝕜} {f : α → ε},
MeasureTheory.eLpNormEssSup (c • f) μ ≤ ‖c‖ₑ * MeasureTheory... | null | true |
_private.Mathlib.RingTheory.Ideal.Pure.0.injective_lTensor_quotient_iff_inf_eq_mul._simp_1_6 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, Function.Injective ⇑f = (f.ker = ⊥) | null | false |
ComplexShape.symmetryEquiv.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₁₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(c₁₂ : ComplexShape I₁₂) →
[inst : TotalComplexShape c₂ c₁ c₁₂] →
(j : I₁₂) →
(motive : ↑(c₂.π c₁ c₁₂ ⁻¹' {j}) → Sort u_4) →
... | null | false |
CategoryTheory.PreGaloisCategory.endEquivSectionsFibers_π | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F]
(f : CategoryTheory.End F) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
↑((CategoryTheory.Pre... | null | true |
Std.PRange.instHasSizeInt_1 | Init.Data.Range.Polymorphic.Int | Std.Rxo.HasSize ℤ | null | true |
instDecidableEqDyckWord.decEq._proof_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (a : List DyckStep) (a_1 : List.count DyckStep.U a = List.count DyckStep.D a), a_1 = a_1 | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.lt_mul_div_self_add._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {k : ℕ}, 0 < k → ¬0 < ↑k → False | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.D | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option (Sigma Std.Time.Day.Ordinal.OfYear) | null | true |
Lean.Widget.GetWidgetsResponse.mk.inj | Lean.Widget.UserWidget | ∀ {widgets widgets_1 : Array Lean.Widget.PanelWidgetInstance},
{ widgets := widgets } = { widgets := widgets_1 } → widgets = widgets_1 | null | true |
Set.Nontrivial.add_left | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] [IsLeftCancelAdd α] {s t : Set α}, t.Nontrivial → s.Nonempty → (s + t).Nontrivial | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r r' : ℤ) (pq : κ)
(hrr' : autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₀_le._auto_1)
(hr : autoParam (r₀ ... | null | true |
MeasureTheory.AddContent.onIoc._proof_16 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] {G : Type u_2} [inst_1 : AddCommGroup G] (f : α → G) (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
(↑I).PairwiseDisjoint id →
⋃₀ ↑I ∈ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
MeasureTheory.AddContent.onIocAux f (⋃₀ ↑I) = ∑ u ∈ I, MeasureTheor... | null | false |
Std.HashMap.getElem_inter | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ ∩ m₂}, (m₁ ∩ m₂)[k] = m₁[k] | null | true |
Mathlib.Tactic.Order.AtomicFact.isBot | Mathlib.Tactic.Order.CollectFacts | ℕ → Mathlib.Tactic.Order.AtomicFact | null | true |
Polynomial.coeff_X_one | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R], Polynomial.X.coeff 1 = 1 | null | true |
MulSemiringAction.smul_mul | Mathlib.Algebra.Ring.Action.Basic | ∀ {M : Type u} {R : Type v} {inst : Monoid M} {inst_1 : Semiring R} [self : MulSemiringAction M R] (g : M) (x y : R),
g • (x * y) = g • x * g • y | Scalar multiplication distributes across multiplication | true |
_private.Init.Data.Iterators.Basic.0.Std.Internal.idOpaque | Init.Data.Iterators.Basic | {α : Sort u_1} → { f // f = id } | null | true |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Icc_factorization_eq_pow_dvd._simp_1_2 | Mathlib.Data.Nat.Factorization.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
CategoryTheory.BasedCategory.recOn | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{motive : CategoryTheory.BasedCategory 𝒮 → Sort u} →
(t : CategoryTheory.BasedCategory 𝒮) →
((obj : Type u₂) →
(category : CategoryTheory.Category.{v₂, u₂} obj) →
(p : CategoryTheory.Functor obj 𝒮) → motive ... | null | false |
Submodule.torsionBy_isTorsionBy | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (a : R),
Module.IsTorsionBy R (↥(Submodule.torsionBy R M a)) a | The `a`-torsion submodule is an `a`-torsion module. | true |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.resolventSet_neg._simp_1_1 | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {α : Type u_2} [inst : Neg α] {s : Set α} {a : α}, (a ∈ -s) = (-a ∈ s) | null | false |
RestrictedProduct.ext | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) (A : (i : ι) → Set (R i)) {𝓕 : Filter ι}
{x y : RestrictedProduct (fun i => R i) (fun i => A i) 𝓕}, (∀ (i : ι), x i = y i) → x = y | null | true |
Left.self_le_inv | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : Preorder α] [MulLeftMono α] {a : α}, a ≤ 1 → a ≤ a⁻¹ | null | true |
_private.Lean.Parser.Level.0.Lean.Parser.initFn._@.Lean.Parser.Level.2271617841._hygCtx._hyg.2 | Lean.Parser.Level | IO Unit | null | false |
CategoryTheory.Limits.StrongEpiMonoFactorisation._sizeOf_inst | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} → (f : X ⟶ Y) → [SizeOf C] → SizeOf (CategoryTheory.Limits.StrongEpiMonoFactorisation f) | null | false |
ENNReal.instAddCommMonoid._proof_1 | Mathlib.Basic.ENNReal.Basic | ∀ (a b : ENNReal), a + b = b + a | null | false |
Mathlib.Tactic.Linarith.CompSource.scale.injEq | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | ∀ (a : ℕ) (a_1 : Mathlib.Tactic.Linarith.CompSource) (a_2 : ℕ) (a_3 : Mathlib.Tactic.Linarith.CompSource),
(Mathlib.Tactic.Linarith.CompSource.scale a a_1 = Mathlib.Tactic.Linarith.CompSource.scale a_2 a_3) =
(a = a_2 ∧ a_1 = a_3) | null | true |
AlgebraicGeometry.AffineSpace.toSpecMvPolyIntEquiv | Mathlib.AlgebraicGeometry.AffineSpace | (n : Type u) →
{X : AlgebraicGeometry.Scheme} →
(X ⟶ AlgebraicGeometry.Spec ↧(MvPolynomial n (ULift.{u, 0} ℤ))) ≃ (n → ↑(X.presheaf.obj (Opposite.op ⊤))) | Morphisms into `Spec ℤ[n]` are equivalent the choice of `n` global sections.
Use `homOverEquiv` instead.
| true |
Std.DTreeMap.Raw.instSliceableRocSlice._auto_1 | Std.Data.DTreeMap.Raw.Slice | Lean.Syntax | null | false |
TopCat.prodBinaryFan | Mathlib.Topology.Category.TopCat.Limits.Products | (X Y : TopCat) → CategoryTheory.Limits.BinaryFan X Y | The explicit binary cofan of `X, Y` given by `X × Y`. | true |
MaxTropical.instCommMonoidOfAddCommMonoid._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddCommMonoid R] (a b : MaxTropical R), a * b = b * a | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.simplicialEvalσ_succ_getElem._proof_1_4 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (head : ℕ) (tail : List ℕ) {k : ℕ}, k + 1 ≤ (head :: tail).length → k < (head :: tail).length | null | false |
MeasureTheory.trim_trim | Mathlib.MeasureTheory.Measure.Trim | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {m₁ m₂ : MeasurableSpace α} {hm₁₂ : m₁ ≤ m₂}
{hm₂ : m₂ ≤ m0}, (μ.trim hm₂).trim hm₁₂ = μ.trim ⋯ | null | true |
Module.Basis.finiteDimensional_of_finite | Mathlib.LinearAlgebra.FiniteDimensional.Defs | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type w}
[Finite ι] (h : Module.Basis ι K V), FiniteDimensional K V | If a vector space has a finite basis, then it is finite-dimensional. | true |
Submodule.idemSemiring._proof_7 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(a : Submodule R A), a * 0 = 0 | null | false |
Std.Sat.AIG.relabelNat'_fst_eq_relabelNat | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {aig : Std.Sat.AIG α}, aig.relabelNat'.1 = aig.relabelNat | null | true |
Real.instNormedAddCommGroupAngle._proof_44 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | autoParam (uniformity Real.Angle = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam | null | false |
CategoryTheory.ShortComplex.homologyπ.eq_1 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
S.homologyπ = CategoryTheory.CategoryStruct.comp S.leftHomologyπ S.leftHomologyIso.hom | null | true |
inv_le_div_iff_le_mul' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c : α}, a⁻¹ ≤ b / c ↔ c ≤ a * b | null | true |
CategoryTheory.Limits.PullbackCone.isLimitOfCompMono | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y Z : C} →
(f : X ⟶ W) →
(g : Y ⟶ W) →
(i : W ⟶ Z) →
[CategoryTheory.Mono i] →
(s : CategoryTheory.Limits.PullbackCone f g) →
CategoryTheory.Limits.IsLimit s →
Catego... | If `W` is the pullback of `f, g`, it is also the pullback of `f ≫ i, g ≫ i` for any mono `i`. | true |
_private.Mathlib.Order.WithBot.0.WithBot.unbotD_eq_self_iff._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} {d y : α} {x : WithBot α}, (WithBot.unbotD d x = y) = (x = ↑y ∨ x = ⊥ ∧ y = d) | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {X : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] {x y : C... | null | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_isLoopAt._simp_1_2 | Mathlib.Combinatorics.Graph.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
ULift.monoidWithZero | Mathlib.Algebra.GroupWithZero.ULift | {α : Type u} → [MonoidWithZero α] → MonoidWithZero (ULift.{u_1, u} α) | null | true |
CategoryTheory.Limits.diagonalObjPullbackFstIso_hom_fst_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) {Z_1 : C} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diagonalObjPullbackFstIso f g).hom
(CategoryTheory.CategoryStruct.comp
(... | null | true |
_private.Mathlib.CategoryTheory.Sites.Coverage.0.CategoryTheory.Coverage.eq_top_pullback._simp_1_1 | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True | null | false |
DividedPowers.subDPIdeal_inf_of_quot | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_2} →
[inst : CommRing A] →
{I : Ideal A} →
{hI : DividedPowers I} →
{J : Ideal A} →
{hJ : DividedPowers (Ideal.map (Ideal.Quotient.mk J) I)} →
{φ : hI.DPMorphism hJ} → φ.toRingHom = Ideal.Quotient.mk J → hI.SubDPIdeal | If there is a divided power structure on `I⬝(A/J)` such that the quotient map is
a dp-morphism, then `J ⊓ I` is a sub-dp-ideal of `I`. | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(a : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K a =
⟦NumberField.mixedEmbedding.fundamentalCone.preimageOfMemIntegerSet a⟧ | null | true |
Subsemigroup.gciMapComap.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N} (hf : Function.Injective ⇑f),
Subsemigroup.gciMapComap hf = ⋯.toGaloisCoinsertion ⋯ | null | true |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_Lp_mul_Lq._simp_1_5 | Mathlib.Analysis.MeanInequalities | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Nat.dist_eq_zero | Mathlib.Data.Nat.Dist | ∀ {n m : ℕ}, n = m → n.dist m = 0 | null | true |
MonoidAlgebra.comapDomain._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_1} {N : Type u_2} [inst : Semiring R] (f : M → N),
Function.Injective f → ∀ (x : MonoidAlgebra R N), Set.InjOn f (f ⁻¹' ↑x.coeff.support) | null | false |
MeasureTheory.isProbabilityMeasure_comap | Mathlib.MeasureTheory.Measure.Typeclasses.Probability | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {μ : MeasureTheory.Measure α}
[MeasureTheory.IsProbabilityMeasure μ] {f : β → α},
Function.Injective f →
(∀ᵐ (a : α) ∂μ, a ∈ Set.range f) →
(∀ (s : Set β), MeasurableSet s → MeasurableSet (f '' s)) →
MeasureTheory.... | null | true |
Set.Ioc.instMul | Mathlib.Algebra.Order.Interval.Set.Instances | {R : Type u_1} → [inst : Semiring R] → [inst_1 : PartialOrder R] → [IsStrictOrderedRing R] → Mul ↑(Set.Ioc 0 1) | null | true |
Algebra.Generators.CotangentSpace.compEquiv | Mathlib.RingTheory.Kaehler.JacobiZariski | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{T : Type u₃} →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : Algebra S T] →
[inst_6 : IsScalarTower R S T] →
... | Given `R[X] → S` and `S[Y] → T`, the cotangent space of `R[X][Y] → T` is isomorphic
to the direct product of the cotangent space of `S[Y] → T` and `R[X] → S` (base changed to `T`). | true |
Action.Functor.mapActionPreservesColimit_of_preserves | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_3}
[inst_1 : CategoryTheory.Category.{v_2, u_3} W] (F : CategoryTheory.Functor V W) (G : Type u_4) [inst_2 : Monoid G]
{J : Type u_5} [inst_3 : CategoryTheory.Category.{v_3, u_5} J] (K : CategoryTheory.Functor J (Action V G))
[CategoryTheo... | `F.mapAction : Action V G ⥤ Action W G` preserves the colimit of some `K : J ⥤ Action V G` if
`K ⋙ forget V G` has a colimit and `F` preserves the colimit of `K ⋙ forget V G`. | true |
CategoryTheory.Limits.Bicone.toBinaryBiconeIsBilimit | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(b : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y)) →
b.toBinaryBicone.IsBilimit ≃ b.IsBilimit | A bicone over a pair is a bilimit bicone if and only if the corresponding binary bicone is a
bilimit. | true |
_private.Lean.Elab.Tactic.Omega.Core.0.Lean.Elab.Tactic.Omega.initFn._@.Lean.Elab.Tactic.Omega.Core.3193685152._hygCtx._hyg.2 | Lean.Elab.Tactic.Omega.Core | IO Unit | null | false |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.lo_ro_2._proof_1_1 | Init.Grind.Offset | ∀ (u w v k₁ k₂ : ℕ), u + k₁ ≤ w → w ≤ v + k₂ → ¬u ≤ v + (k₂ - k₁) → False | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.Slice.endsWith_prop_iff_get._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice},
(s.endsWith p = true) = ∃ (h : s.endPos ≠ s.startPos), p ((s.endPos.prev h).get ⋯) = true | null | false |
AddChar.expect_ne_zero_iff_eq_zero | Mathlib.Analysis.Fourier.FiniteAbelian.Orthogonality | ∀ {G : Type u_1} {R : Type u_2} [inst : AddGroup G] [inst_1 : Fintype G] [inst_2 : Semifield R] [inst_3 : CharZero R]
{ψ : AddChar G R}, (Finset.univ.expect fun x => ψ x) ≠ 0 ↔ ψ = 0 | null | true |
Matrix.isIrreducible_transpose_iff | Mathlib.LinearAlgebra.Matrix.Irreducible.Defs | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] {A : Matrix n n R},
A.transpose.IsIrreducible ↔ A.IsIrreducible | null | true |
ZeroAtInftyContinuousMap.instNonUnitalCommCStarAlgebra._proof_7 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalCommCStarAlgebra A]
(a b c : ZeroAtInftyContinuousMap α A), (a + b) * c = a * c + b * c | null | false |
_private.Lean.Meta.Constructions.SparseCasesOn.0.Lean.Meta.instBEqSparseCasesOnKey.beq | Lean.Meta.Constructions.SparseCasesOn | Lean.Meta.SparseCasesOnKey✝ → Lean.Meta.SparseCasesOnKey✝ → Bool | null | true |
CommSemiring.toCoalgebra | Mathlib.RingTheory.Coalgebra.Basic | (R : Type u) → [inst : CommSemiring R] → Coalgebra R R | Every commutative (semi)ring is a coalgebra over itself, with `Δ r = 1 ⊗ₜ r`. | true |
_private.Lean.Meta.Canonicalizer.0.Lean.Meta.Canonicalizer.canon.match_4 | Lean.Meta.Canonicalizer | (motive : Option (List Lean.Expr) → Sort u_1) →
(x : Option (List Lean.Expr)) →
((es' : List Lean.Expr) → motive (some es')) → ((x : Option (List Lean.Expr)) → motive x) → motive x | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.closer | Lean.DocString.Parser | ℕ → Lean.Parser.ParserFn | null | true |
_private.Mathlib.Order.Lattice.0.pairwise_iff_lt._simp_1_3 | Mathlib.Order.Lattice | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
IsMinFilter.neg | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : AddCommGroup β] [inst_1 : PartialOrder β] [IsOrderedAddMonoid β] {f : α → β} {a : α}
{l : Filter α}, IsMinFilter f l a → IsMaxFilter (fun x => -f x) l a | null | true |
Manifold.IsSubmersion | Mathlib.Geometry.Manifold.Submersion | {𝕜 : Type u_1} →
{E'' : Type u_3} →
{H : Type u_7} →
{G : Type u_9} →
{E : Type u} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup E''] →
[inst_... | `f : M → N` is a `C^n` submersion if around each point `x ∈ M`,
there are charts `φ` and `ψ` of `M` and `N` around `x` and `f x`, respectively
such that in these charts, `f` looks like `(u, v) ↦ u`.
Implicit in this definition is an abstract choice `F` of a complement of `E` in `E'`:
being a submersion includes a choi... | true |
AnalyticOnNhd.iteratedFDeriv | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{s : Set E} [CompleteSpace F], AnalyticOnNhd 𝕜 f s → ∀ (n : ℕ), AnalyticOnNhd 𝕜 (iteratedFDeriv 𝕜 n f... | If a function is analytic on a set `s`, so are its successive Fréchet derivative. See also
`AnalyticOnNhd.iteratedFDeriv_of_isOpen`, removing the completeness assumption but requiring the set
to be open. | true |
_private.Mathlib.Order.JordanHolder.0.CompositionSeries.snoc_eraseLast_last._simp_1_1 | Mathlib.Order.JordanHolder | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
Module.Basis.repr_eq_iff' | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_7} {R : Type u_8} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{b : Module.Basis ι R M} {f : M ≃ₗ[R] ι →₀ R}, b.repr = f ↔ ∀ (i : ι), f (b i) = fun₀ | i => 1 | null | true |
_private.Lean.Server.Requests.0.Lean.Server.RequestM.waitFindSnapAux.match_1 | Lean.Server.Requests | (motive : Except IO.Error (Option Lean.Server.Snapshots.Snapshot) → Sort u_1) →
(x : Except IO.Error (Option Lean.Server.Snapshots.Snapshot)) →
((e : IO.Error) → motive (Except.error e)) →
(Unit → motive (Except.ok none)) →
((snap : Lean.Server.Snapshots.Snapshot) → motive (Except.ok (some snap))) →... | null | false |
_private.Batteries.Tactic.GeneralizeProofs.0.Batteries.Tactic.GeneralizeProofs.withGeneralizedProofs.match_1 | Batteries.Tactic.GeneralizeProofs | (motive : Lean.Expr × Array (Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Lean.Expr × Array (Lean.Expr × Lean.Expr)) →
((e : Lean.Expr) → (generalizations : Array (Lean.Expr × Lean.Expr)) → motive (e, generalizations)) → motive x | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.close | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Unbounded✝ α → EIO Std.CloseableChannel.Error Unit | null | true |
_private.Mathlib.MeasureTheory.Constructions.Pi.0.MeasureTheory.measurePreserving_arrowProdEquivProdArrow._simp_1_3 | Mathlib.MeasureTheory.Constructions.Pi | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
CategoryTheory.Square.evaluation₁._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Square C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.CategoryStruct.comp f g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁ | null | false |
Int32.toNatClampNeg_pos_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ (n : Int32), (0 < n.toNatClampNeg) = (0 < n) | null | false |
Submonoid.mk_smul | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} [inst : MulOneClass M'] [inst_1 : SMul M' α] {S : Submonoid M'} (g : M') (hg : g ∈ S)
(a : α), ⟨g, hg⟩ • a = g • a | null | true |
LocallyConstant.mapMonoidHom.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {Z : Type u_6} [inst_1 : MulOneClass Y]
[inst_2 : MulOneClass Z] (f : Y →* Z),
LocallyConstant.mapMonoidHom f = { toFun := LocallyConstant.map ⇑f, map_one' := ⋯, map_mul' := ⋯ } | null | true |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₁Toδ₀_of_isZero | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₁ i₂ i₃ i₄ i₅ : ι}
(f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₂₃ : i₁ ⟶ i₃)
(h₂₃ : ... | null | true |
MvPFunctor.M.dest | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → {α : TypeVec.{u} n} → P.M α → ↑P (α ::: P.M α) | Destructor for M-types | true |
Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast.sizeOf_spec | Mathlib.Tactic.Translate.UnfoldBoundary | ∀ (declName unfold refold unfold' refold' : Lean.Name),
sizeOf (Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast declName unfold refold unfold' refold') =
1 + sizeOf declName + sizeOf unfold + sizeOf refold + sizeOf unfold' + sizeOf refold' | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.casesOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t | null | false |
Filter.CardinalGenerateSets.casesOn | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop}
{a : Set α} (t : Filter.CardinalGenerateSets g a),
(∀ {s : Set α} (a : s ∈ g), motive s ⋯) →
motive Set.univ ⋯ →
(∀ {s t : Set α} (a : Filter.CardinalGenerateSets g s) (a_1 : s ⊆ t), motive ... | null | false |
DifferentiableAt.inv._simp_2 | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_4} [inst_3 : NormedDivisionRing R] [inst_4 : NormedAlgebra 𝕜 R] {h : E → R}
{z : E}, DifferentiableAt 𝕜 h z → h z ≠ 0 → DifferentiableAt 𝕜 h⁻¹ z = True | null | false |
AddSubgroup.finiteIndex_toSubgroup_iff._simp_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_3} [inst : AddGroup G] (H : AddSubgroup G), (AddSubgroup.toSubgroup H).FiniteIndex = H.FiniteIndex | null | false |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.lcm._unary._proof_1 | Lean.Meta.Sym.Arith.Poly | WellFounded (invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceBmod._regBuiltin.Int.reduceBmod.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.618080867._hygCtx._hyg.25 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | null | false |
CochainComplex.ConnectData.d_comp_d | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m p : ℤ),
CategoryTheory.CategoryStruct.comp (h.d n m) (h.d m p) = 0 | null | true |
Pell.Solution₁.instCommGroup._proof_6 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d), 1 * a = a | null | false |
Lean.Lsp.instFromJsonSignatureHelpOptions | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpOptions | null | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.isCocircuit_iff_minimal_compl_nonspanning._simp_1_3 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {s t u : Set α}, (s ⊆ t \ u) = (s ⊆ t ∧ Disjoint s u) | null | false |
Homeomorph.inv.eq_1 | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ (G : Type u_4) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = { toEquiv := Equiv.inv G, continuous_toFun := ⋯, continuous_invFun := ⋯ } | null | true |
SubNegMonoid.mk._flat_ctor | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
(zero : G) →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
autoParam (∀ (x : G), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n ... | null | false |
Set.projIcc_eq_right | Mathlib.Order.Interval.Set.ProjIcc | ∀ {α : Type u_1} [inst : LinearOrder α] {a b x : α} (h : a < b), Set.projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x | null | true |
CategoryTheory.Bicategory.Adj.inst._proof_24 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.Adj.Bicategory.associator f (CategoryTheory.CategoryStruct.id b) g).hom
(CategoryTheory.Bicategory.Adj.Bicategory.whiskerLe... | null | false |
Lean.LLVM.createStringAttribute | Lean.Compiler.IR.LLVMBindings | {ctx : Lean.LLVM.Context} → String → String → BaseIO (Lean.LLVM.Attribute ctx) | null | true |
_private.Mathlib.Topology.UniformSpace.Separation.0.t0Space_iff_ker_uniformity._simp_1_6 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {x : α × α}, (x ∈ Set.diagonal α) = (x.1 = x.2) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.