name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Function.mtr | Mathlib.Logic.Basic | ∀ {a b : Prop}, (¬a → ¬b) → b → a | Provide the reverse of modus tollens (`mt`) as dot notation for implications. | true |
DFinsupp.equivFunOnFintype_symm_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (f : Π₀ (i : ι), β i),
DFinsupp.equivFunOnFintype.symm ⇑f = f | null | true |
AddCommGroup.nsmul_add_modEq | Mathlib.Algebra.Group.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoid M] {a p : M} (n : ℕ), n • p + a ≡ a [PMOD p] | null | true |
Mathlib.Tactic.Widget.StringDiagram.Node.recOn | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
(t : Mathlib.Tactic.Widget.StringDiagram.Node) →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.... | null | false |
SimpleGraph.Hom.toCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} →
{β : Type u_5} → {A : SimpleGraph α} → {B : SimpleGraph β} → (f : A →g B) → Function.Injective ⇑f → A.Copy B | An injective homomorphism gives rise to a copy. | true |
List.forIn'_pure_yield_eq_foldl | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {l : List α}
(f : (a : α) → a ∈ l → β → β) (init : β),
(forIn' l init fun a m_1 b => pure (ForInStep.yield (f a m_1 b))) =
pure
(List.foldl
(fun b x =>
match x with
| ⟨a, h⟩ => f a h b)
... | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Frontend.0.Lean.Elab.Tactic.Do.Internal.parseInvariantMap._sparseCasesOn_7 | Lean.Elab.Tactic.Do.Internal.VCGen.Frontend | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : Semiring R] (a b : R) (m n : ℕ),
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(n + 1))) =
(Polynomial.monomial (m + 1 - 1 + (n + 1))) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1 - 1)))... | null | false |
_private.Mathlib.Algebra.Order.Ring.Ordering.Basic.0.RingPreordering.supportAddSubgroup_eq_bot._simp_1_1 | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, (x ∈ P.supportAddSubgroup) = (x ∈ P ∧ -x ∈ P) | null | false |
MeasureTheory.LocallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | {X : Type u_1} →
{ε : Type u_3} →
[inst : MeasurableSpace X] →
[TopologicalSpace X] →
[inst_2 : TopologicalSpace ε] →
[ContinuousENorm ε] →
(X → ε) → autoParam (MeasureTheory.Measure X) MeasureTheory.LocallyIntegrable._auto_1 → Prop | A function `f : X → ε` is *locally integrable* if it is integrable on a neighborhood of every
point. In particular, it is integrable on all compact sets,
see `LocallyIntegrable.integrableOn_isCompact`. | true |
LieSubalgebra.mem_normalizer_iff' | Mathlib.Algebra.Lie.Normalizer | ∀ {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, ⁅y, x⁆ ∈ H | null | true |
IsAlgebraic.nontrivial | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → Nontrivial R | null | true |
CategoryTheory.Limits.preservesFiniteLimits_of_op | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F.op],
CategoryTheory.Limits.PreservesFiniteLimits F | If `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits, then `F : C ⥤ D` preserves finite limits. | true |
IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_8 : CommRing Sₚ] [inst_9 : Algebra S Sₚ]
... | null | true |
Cardinal.mk_univ_real | Mathlib.Analysis.Real.Cardinality | Cardinal.mk ↑Set.univ = Cardinal.continuum | The cardinality of the reals, as a set. | true |
Lean.Grind.CommRing.Expr._sizeOf_inst | Init.Grind.Ring.CommSolver | SizeOf Lean.Grind.CommRing.Expr | null | false |
LieRinehartAlgebra | Mathlib.Algebra.LieRinehartAlgebra.Defs | (R : Type u_1) →
(A : Type u_2) →
(L : Type u_3) →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
[LieRinehartRing A L] → [inst_5 : CommRing R] → [Algebra R A] → [LieAlgebra R L] → Prop | A Lie-Rinehart algebra with coefficients in a commutative ring `R`, is a pair consisting of a
commutative `R`-algebra `A` and a Lie algebra `L` with coefficients in `R`, such that `A` and `L`
are each a module over the other, satisfying compatibility conditions.
As shown below, this data determines a linear map `L → D... | true |
sdiff_right_inj | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x ≤ z → y ≤ z → (z \ x = z \ y ↔ x = y) | null | true |
MeasureTheory.average | Mathlib.MeasureTheory.Integral.Average | {α : Type u_1} →
{E : Type u_2} →
{m0 : MeasurableSpace α} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → MeasureTheory.Measure α → (α → E) → E | Average value of a function `f` w.r.t. a measure `μ`, denoted `⨍ x, f x ∂μ`.
It is equal to `(μ.real univ)⁻¹ • ∫ x, f x ∂μ`, so it takes value zero if `f` is not integrable or
if `μ` is an infinite measure. If `μ` is a probability measure, then the average of any function is
equal to its integral.
For the average on ... | true |
Lean.Elab.SyntaxDeprecationEntry.ctorIdx | Lean.Elab.DeprecatedSyntax | Lean.Elab.SyntaxDeprecationEntry → ℕ | null | false |
MvPowerSeries.X_dvd_iff | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] {s : σ} {φ : MvPowerSeries σ R},
MvPowerSeries.X s ∣ φ ↔ ∀ (m : σ →₀ ℕ), m s = 0 → (MvPowerSeries.coeff m) φ = 0 | null | true |
intervalIntegral.integral_hasDerivAt_of_tendsto_ae_right | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {c : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
StronglyMeasurableAtFilter f (nhds b) MeasureTheory.volume →
Filter.Tendsto f (nhds b ⊓ MeasureTheory.ae MeasureTheory.volume) (nhds c)... | **Fundamental theorem of calculus-1**: if `f : ℝ → E` is integrable on `a..b` and `f x` has a
finite limit `c` almost surely at `b`, then `u ↦ ∫ x in a..u, f x` has derivative `c` at `b`. | true |
Lean._aux_Lean_Message___macroRules_Lean_termM!__1 | Lean.Message | Lean.Macro | null | false |
CategoryTheory.Preadditive.isSeparator_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsSeparator G ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = 0) → f = 0 | null | true |
_private.Mathlib.RingTheory.WittVector.WittPolynomial.0.xInTermsOfW_vars_aux._proof_1_3 | Mathlib.RingTheory.WittVector.WittPolynomial | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], NeZero p | null | false |
LinearMap.range_eq_top_of_surjective | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [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₂}
[inst_6 : RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂), Function.Surjective ⇑f → f.range = ⊤ | null | true |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.foldlMAux.match_1 | Lean.Data.PersistentArray | {α : Type u_1} →
{β : Type u_3} →
(motive : Lean.PersistentArrayNode α → β → Sort u_2) →
(x : Lean.PersistentArrayNode α) →
(x_1 : β) →
((cs : Array (Lean.PersistentArrayNode α)) → (b : β) → motive (Lean.PersistentArrayNode.node cs) b) →
((vs : Array α) → (b : β) → motive (Lean... | null | false |
AnalyticAt.fun_pow | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {A : Type u_7} [inst_3 : NormedRing A] [inst_4 : NormedAlgebra 𝕜 A] {f : E → A} {z : E},
AnalyticAt 𝕜 f z → ∀ (n : ℕ), AnalyticAt 𝕜 (fun i => f i ^ n) z | Eta-expanded form of `AnalyticAt.pow`
---
Powers of analytic functions (into a normed `𝕜`-algebra) are analytic. | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.hasSum_nat_jacobiTheta._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
RootPairing.flipEquiv._proof_1 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ (ι : Type u_1) (R : Type u_2) (M : Type u_3) (N : Type u_4) [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N],
Function.LeftInverse (fun P => P.flip) fun P => P.flip | null | false |
Affine.Simplex.sum_excenterWeights | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1)))
[inst_5 : Decidable (s.ExcenterExists signs)],
∑ i, s.excenterWeights signs i... | null | true |
IsBaseChange.directSumPow | Mathlib.RingTheory.TensorProduct.IsBaseChangePi | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (ι : Type u_3)
{M : Type u_6} {M' : Type u_7} [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M]
[inst_6 : Module R M'] [inst_7 : Module S M'] [inst_8 : IsScalarTower R S M'] {ε : M →ₗ[... | Base change for direct sums of a constant module. | true |
List.insert_replicate_self | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α},
0 < n → List.insert a (List.replicate n a) = List.replicate n a | null | true |
Polynomial.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
HasStrictDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x | The derivative (in the analysis sense) of a polynomial `p` is given by `p.derivative`. | true |
PartOrdEmb.isCardinalFiltered_iff | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ (κ : Cardinal.{u}) [inst : Fact κ.IsRegular] (X : PartOrdEmb),
PartOrdEmb.isCardinalFiltered κ X ↔ CategoryTheory.IsCardinalFiltered (↑X) κ | null | true |
ProbabilityTheory.condIndepFun_iff_condExp_inter_preimage_eq_mul | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'},
Measurable f →
Measurable g →
(... | null | true |
CategoryTheory.Bimon.instBimonObjXXMon | Mathlib.CategoryTheory.Monoidal.Bimon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → (M : CategoryTheory.Bimon C) → CategoryTheory.BimonObj M.X.X | null | true |
CommMonCat.units._proof_1 | Mathlib.Algebra.Category.Grp.Adjunctions | ∀ (x : CommMonCat),
CommGrpCat.ofHom (Units.map (CommMonCat.Hom.hom (CategoryTheory.CategoryStruct.id x))) =
CategoryTheory.CategoryStruct.id (CommGrpCat.of (↑x)ˣ) | null | false |
AlgHom.toOpposite._proof_2 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x * y) = (↑↑(f.toOpposite hf)).toFun x * (↑↑(f.toOpposite h... | null | false |
sub_one_mul_padicValNat_choose_eq_sub_sum_digits' | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p k n : ℕ} [hp : Fact (Nat.Prime p)],
(p - 1) * padicValNat p ((n + k).choose k) = (p.digits k).sum + (p.digits n).sum - (p.digits (n + k)).sum | **Kummer's Theorem**
Taking (`p - 1`) times the `p`-adic valuation of the binomial `n + k` over `k` equals the sum of the
digits of `k` plus the sum of the digits of `n` minus the sum of digits of `n + k`, all base `p`.
| true |
CategoryTheory.SingleFunctors.map_lift_shiftIso_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctorsLift | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{u_7, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] [inst_2 : CategoryTheory.Category.{u_5, u_3} E] {A : Type u_4}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | true |
Subtype.instTotalLE | Init.Data.Subtype.Order | ∀ {α : Type u} [inst : LE α] [i : Std.Total fun x1 x2 => x1 ≤ x2] {P : α → Prop}, Std.Total fun x1 x2 => x1 ≤ x2 | null | true |
CategoryTheory.Endofunctor.Coalgebra.Hom.id._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
(V : CategoryTheory.Endofunctor.Coalgebra F),
CategoryTheory.CategoryStruct.comp V.str (F.map (CategoryTheory.CategoryStruct.id V.V)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id V.V) V.str | null | false |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.mk_eq_bot._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, (r₁ = r₂) = (⇑r₁ = ⇑r₂) | null | false |
InverseSystem.piSplitLE._proof_14 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {i : ι} [inst : PartialOrder ι], i ≤ i | null | false |
InnerProductSpace.toDual_apply_eq_toDualMap_apply | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (x : E), (InnerProductSpace.toDual 𝕜 E) x = (InnerProductSpace.toDualMap 𝕜 E) x | null | true |
_private.Mathlib.Topology.Constructions.SumProd.0.isOpenMap_inr._simp_1_1 | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set (X ⊕ Y)},
IsOpen s = (IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)) | null | false |
SimpleGraph.Subgraph.coeCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {G : SimpleGraph V} → (G' : G.Subgraph) → G'.coe.Copy G | A `Subgraph G` gives rise to a copy from the coercion to `G`. | true |
DiscreteQuotient.equivFinsetClopens | Mathlib.Topology.DiscreteQuotient | (X : Type u_2) →
[inst : TopologicalSpace X] →
[inst_1 : CompactSpace X] → DiscreteQuotient X ≃ ↑(Set.range (DiscreteQuotient.finsetClopens X)) | The discrete quotients of a compact space are in bijection with a subtype of the type of
`Finset (Clopens X)`.
TODO: show that this is precisely those finsets of clopens which form a partition of `X`.
| true |
ULiftable.up' | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} → {g : Type v₀ → Type v₁} → [ULiftable f g] → f PUnit.{u₀ + 1} → g PUnit.{v₀ + 1} | A version of `up` for a `PUnit` return type. | true |
SimpleGraph.map_neighborFinset_induce_of_neighborSet_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj] {v : ↑s},
G.neighborSet ↑v ⊆ s →
Finset.map (Function.Embedding.subtype fun x => x ∈ s) ((SimpleGraph.induce s G).neighborFinset v) =
G.neighborFinset ↑v | null | true |
List.pmap_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {p : { x // x ∈ l } → Prop} {f : (a : { x // x ∈ l }) → p a → β}
(H : ∀ a ∈ l.attach, p a), List.pmap f l.attach H = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.errorMessage.match_6 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(err : Mathlib.Linter.TextBased.StyleError✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.adaptationNote✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleError.windowsLineEnding✝) →
(Unit → motive Mathlib.Linter.TextBased.StyleErro... | null | false |
CategoryTheory.PreOneHypercover.inv_hom_h₁_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S} (e : E ≅ F)
{i j : F.I₀} (k : F.I₁ i j) {Z : C} (h : F.Y (e.hom.s₁ (e.inv.s₁ k)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₁ k) (CategoryTheory.CategoryStruct.comp (e.hom.h₁ (e.inv.s₁ k)) h) =
Categ... | null | true |
Polynomial.eraseLead_monomial | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), ((Polynomial.monomial i) r).eraseLead = 0 | null | true |
AddSemiconjBy.unop | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {a x y : αᵃᵒᵖ},
AddSemiconjBy a x y → AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) | null | true |
Equiv.sigmaSumDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (p : (i : ι) × (α i ⊕ β i)),
(Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd | null | true |
Real.RingHom.unique | Mathlib.Algebra.Order.Archimedean.Real.Hom | Unique (ℝ →+* ℝ) | There exists no nontrivial ring homomorphism `ℝ →+* ℝ`. | true |
Num.mod.eq_3 | Mathlib.Data.Num.ZNum | ∀ (a b : PosNum), (Num.pos a).mod (Num.pos b) = a.mod' b | null | true |
ContinuousCohomology.continuousCohomologyZeroIso._proof_3 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] {X Y : Action (TopModuleCat R) G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((continuousCohomology R G 0).map f)
((CategoryTheory.ShortComple... | null | false |
Metric.exists_isBounded_image_of_tendsto | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace β] {l : Filter α} {f : α → β} {x : β},
Filter.Tendsto f l (nhds x) → ∃ s ∈ l, Bornology.IsBounded (f '' s) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_filter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
CategoryTheory.Limits.prod.map_mono | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] [inst_3 : CategoryTheory.Limits.HasBinaryProduct W X]
[inst_4 : CategoryTheory.Limits.HasBinaryProduct Y Z], CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g) | null | true |
List.step_iter_cons | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {x : β} {xs : List β}, (x :: xs).iter.step = ⟨Std.IterStep.yield xs.iter x, ⋯⟩ | null | true |
LieModule.rank_le_finrank | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : LieRingModule L M] [inst_8 : LieModule R L M] [inst_9 : Module.Finite R M] [inst_10 : Mo... | null | true |
CategoryTheory.Square.toArrowArrowFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.homMk φ.τ₁ φ.τ₃ ⋯)
(CategoryTheory.Arrow.mk (CategoryTheory.Arrow.homMk Y.f₁₂ Y.f₃₄ ⋯)).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | false |
tacticSimp_wf | Init.WFTactics | Lean.ParserDescr | Unfold definitions commonly used in well founded relation definitions.
Since Lean 4.12, Lean unfolds these definitions automatically before presenting the goal to the
user, and this tactic should no longer be necessary. Calls to `simp_wf` can be removed or replaced
by plain calls to `simp`.
| true |
Set.Finite.isGδ_compl | Mathlib.Topology.Separation.GDelta | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} [T1Space X], s.Finite → IsGδ sᶜ | null | true |
LieAlgebra.Orthogonal.typeB | Mathlib.Algebra.Lie.Classical | (l : Type u_4) →
(R : Type u₂) →
[inst : DecidableEq l] →
[inst_1 : CommRing R] → [inst_2 : Fintype l] → LieSubalgebra R (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | The classical Lie algebra of type B as a Lie subalgebra of matrices associated to the matrix
`JB`. | true |
CategoryTheory.Over.opEquivOpUnder._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) {Z Y : (CategoryTheory.Under X)ᵒᵖ} (f : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Under.Hom.right f.unop).op
(CategoryTheory.Over.mk (Opposite.unop Y).hom.op).hom =
(CategoryTheory.Over.mk (Opposite.unop Z).hom.op).hom | null | false |
Array.PrefixTable.step | Batteries.Data.Array.Match | {α : Type u_1} → [BEq α] → (t : Array.PrefixTable α) → α → Fin (t.size + 1) → Fin (t.size + 1) | Transition function for the KMP matcher
Assuming we have an input `xs` with a suffix that matches the pattern prefix `t.pattern[:len]`
where `len : Fin (t.size+1)`. Then `xs.push x` has a suffix that matches the pattern prefix
`t.pattern[:t.step x len]`. If `len` is as large as possible then `t.step x len` will also b... | true |
preservesBinaryCoproducts_of_preservesInitial_and_pushouts | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) F]
[... | A functor that preserves initial objects and pushouts preserves binary coproducts. | true |
Finset.sigmaLift | Mathlib.Data.Finset.Sigma | {ι : Type u_1} →
{α : ι → Type u_2} →
{β : ι → Type u_3} →
{γ : ι → Type u_4} → [DecidableEq ι] → (⦃i : ι⦄ → α i → β i → Finset (γ i)) → Sigma α → Sigma β → Finset (Sigma γ) | Lifts maps `α i → β i → Finset (γ i)` to a map `Σ i, α i → Σ i, β i → Finset (Σ i, γ i)`. | true |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_map_app_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) {X_1 Y : CategoryTheory.Functor J₂ C}
(f : X_1 ⟶ Y)... | null | true |
MeasureTheory.measureReal_union_null | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
μ.real s₁ = 0 → μ.real s₂ = 0 → μ.real (s₁ ∪ s₂) = 0 | null | true |
Std.TreeMap.Raw.Equiv.minEntry?_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.minEntry? = t₂.minEntry? | null | true |
Polynomial.C_mul_X_pow_eq_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a | null | true |
MeasureTheory.lintegral_liminf_le' | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_3} {f : ι → α → ENNReal}
{u : Filter ι} [u.IsCountablyGenerated],
(∀ (i : ι), AEMeasurable (f i) μ) →
∫⁻ (a : α), Filter.liminf (fun i => f i a) u ∂μ ≤ Filter.liminf (fun i => ∫⁻ (a : α), f i a ∂μ) u | **Fatou's lemma**, version with `AEMeasurable` functions. | true |
LeanSearchClient.LoogleResult.noConfusionType | LeanSearchClient.LoogleSyntax | Sort u → LeanSearchClient.LoogleResult → LeanSearchClient.LoogleResult → Sort u | null | false |
CategoryTheory.MorphismProperty.Under.instCreatesFiniteColimitsTopUnderForget._proof_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) [CategoryTheory.Limits.HasPushouts T],
CategoryTheory.Limits.HasColimitsOfShape CategoryTheory.Limits.WalkingSpan (CategoryTheory.Under X) | null | false |
MvPolynomial.isWeightedHomogeneous_X | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (i : σ),
MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i) | An indeterminate `i : σ` is weighted homogeneous of degree `w i`. | true |
TopologicalLattice.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Lattice L] →
{motive : TopologicalLattice L → Sort u} →
([toContinuousInf : ContinuousInf L] → [toContinuousSup : ContinuousSup L] → motive ⋯) →
(t : TopologicalLattice L) → motive t | null | false |
SimpleGraph.killCopies.edgeSet.instFintype | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} →
{W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → [Fintype ↑G.edgeSet] → Fintype ↑(G.killCopies H).edgeSet | null | true |
CategoryTheory.ObjectProperty.strictColimitsOfShape_bot | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [Nonempty J], ⊥.strictColimitsOfShape J = ⊥ | null | true |
Lean.Meta.Sym.Arith.CommSemiring.addFn?._inherited_default | Lean.Meta.Sym.Arith.Types | Option Lean.Expr | null | false |
HasSummableGeomSeries.rec | Mathlib.Analysis.SpecificLimits.Normed | {K : Type u_4} →
[inst : NormedRing K] →
{motive : HasSummableGeomSeries K → Sort u} →
((summable_geometric_of_norm_lt_one : ∀ (ξ : K), ‖ξ‖ < 1 → Summable fun n => ξ ^ n) → motive ⋯) →
(t : HasSummableGeomSeries K) → motive t | null | false |
HNNExtension.NormalWord.ReducedWord.prod.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (w : HNNExtension.NormalWord.ReducedWord G A B),
HNNExtension.NormalWord.ReducedWord.prod φ w =
HNNExtension.of w.head * (List.map (fun x => HNNExtension.t ^ ↑x.1 * HNNExtension.of x.2) w.toList).prod | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Multivariate.0.ProbabilityTheory.charFun_stdGaussian._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ (r : ℝ) (n : ℕ), ↑r ^ n = ↑(r ^ n) | null | false |
MeasureTheory.FiniteMeasure.restrict_biUnion_finset | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_3} {μ : MeasureTheory.FiniteMeasure Ω} {T : Finset ι}
{s : ι → Set Ω},
(↑T).Pairwise (Function.onFun Disjoint s) →
(∀ (i : ι), MeasurableSet (s i)) → μ.restrict (⋃ i ∈ T, s i) = ∑ i ∈ T, μ.restrict (s i) | null | true |
MeasureTheory.Filtration.mono | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {i j : ι}
(f : MeasureTheory.Filtration ι m), i ≤ j → ↑f i ≤ ↑f j | null | true |
FinEnum.instUInt64 | Mathlib.Data.FinEnum | FinEnum UInt64 | null | true |
Prod.mk_le_swap._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x : α × β} {a : α} {b : β},
((b, a) ≤ x.swap) = ((a, b) ≤ x) | null | false |
Function.locallyFinsuppWithin.instAddGroup._proof_4 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℕ), ⇑(n • D) = n • ⇑D | null | false |
CategoryTheory.Abelian.Ext.preadditiveYoneda_homologySequenceδ_singleTriangle_apply._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {n₀ n₁ : ℕ}, 1 + n₀ = n₁ → ↑n₀ + 1 = ↑n₁ | null | false |
Module.Flat.rTensor_exact | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
⦃N : Type u_1⦄ ⦃N' : Type u_2⦄ ⦃N'' : Type u_3⦄ [inst_4 : AddCommGroup N] [inst_5 : AddCommGroup N']
[inst_6 : AddCommGroup N''] [inst_7 : Module R N] [inst_8 : Module R N'] [inst_9 : Module R N''] ⦃f :... | If `M` is flat then `- ⊗ M` is an exact functor. | true |
Similar.comp_left_iff | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₁ P₃] [DilationClass F P₁ P₃] (f : F), Similar (⇑f ∘ v₁) v₂ ↔ Similar v₁ v₂ | null | true |
WeierstrassCurve.Jacobian.negAddY._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | (2 + 1).AtLeastTwo | null | false |
Std.DTreeMap.Raw.alter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] →
Std.DTreeMap.Raw α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.DTreeMap.Raw α β cmp | Modifies in place the value associated with a given key,
allowing creating new values and deleting values via an `Option` valued replacement function.
This function ensures that the value is used linearly.
| true |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore | Lean.Meta.Tactic.Generalize | Lean.MVarId → Array Lean.Meta.GeneralizeArg → Lean.Meta.TransparencyMode → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | Telescopic `generalize` tactic. It can simultaneously generalize many terms.
It uses `kabstract` to occurrences of the terms that need to be generalized.
| true |
List.set | Init.Prelude | {α : Type u_1} → List α → ℕ → α → List α | Replaces the value at (zero-based) index `n` in `l` with `a`. If the index is out of bounds, then
the list is returned unmodified.
Examples:
* `["water", "coffee", "soda", "juice"].set 1 "tea" = ["water", "tea", "soda", "juice"]`
* `["water", "coffee", "soda", "juice"].set 4 "tea" = ["water", "coffee", "soda", "juice"... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.