name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearMap.toSpanSingleton | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → M → R →ₗ[R] M | Given an element `x` of a module `M` over `R`, the natural map from
`R` to scalar multiples of `x`. See also `LinearMap.ringLmapEquivSelf`. | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.weight_add_weight_pairMap | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommRing R] [inst_1 : DecidableEq σ] [inst_2 : Fintype σ] {k : ℕ},
∀ t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k,
MvPolynomial.NewtonIdentities.weight✝ σ R k t +
MvPolynomial.NewtonIdentities.weight✝ σ R k (MvPolynomial.NewtonIdentities.pairMap✝ σ t) =
0 | null | true |
AlgebraicGeometry.Scheme.smallPretopology._proof_4 | Mathlib.AlgebraicGeometry.Sites.Small | ∀ (P Q : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) {S : AlgebraicGeometry.Scheme} [P.IsMultiplicative],
(CategoryTheory.Precoverage.comap (CategoryTheory.MorphismProperty.Over.forget Q ⊤ S)
(CategoryTheory.Precoverage.over S (AlgebraicGeometry.Scheme.precoverage P))).IsStableUnderComposition | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.dvd_solve_elim' | Init.Data.Int.Linear | ∀ {x d₁ a₁ p₁ d₂ a₂ p₂ d : ℤ},
d = ↑((a₁ * d₂).gcd (a₂ * d₁)) → d₁ ∣ a₁ * x + p₁ → d₂ ∣ a₂ * x + p₂ → d ∣ a₂ * p₁ - a₁ * p₂ | null | true |
Aesop.RuleResult._sizeOf_1 | Aesop.Search.Expansion | Aesop.RuleResult → ℕ | null | false |
List.map_injective_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (List.map f) = Function.Injective f | null | false |
Finsupp.instZero._proof_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (x : α), x ∈ ∅ ↔ 0 x ≠ 0 | null | false |
continuousSubring._proof_5 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace R] [inst_2 : Ring R]
[inst_3 : IsTopologicalRing R] {a b : α → R},
a ∈ (continuousAddSubgroup α R).carrier →
b ∈ (continuousAddSubgroup α R).carrier → a + b ∈ (continuousAddSubgroup α R).carrier | null | false |
FundamentalGroupoid.termπₘ | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Lean.ParserDescr | The functor between fundamental groupoids induced by a continuous map. | true |
Lean.Parser.checkSimpFailure | Init.Notation | Lean.ParserDescr | `#check_simp t !~>` checks `simp` fails on reducing `t`.
| true |
Metric.unitSphere.coe_pow | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(x : ↑(Metric.sphere 0 1)) (n : ℕ), ↑(x ^ n) = ↑x ^ n | null | true |
SimpleGraph.deleteIncidenceSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → V → SimpleGraph V | Given a vertex `x`, remove the edges incident to `x` from the edge set. | true |
ExistsContDiffBumpBase.y | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → [FiniteDimensional ℝ E] → [inst_3 : MeasurableSpace E] → [BorelSpace E] → ℝ → E → ℝ | An auxiliary function to construct partitions of unity on finite-dimensional real vector spaces.
It is the convolution between a smooth function of integral `1` supported in the ball of radius `D`,
with the indicator function of the closed unit ball. Therefore, it is smooth, equal to `1` on the
ball of radius `1 - D`, ... | true |
Finset.mem_map'._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, (f a ∈ Finset.map f s) = (a ∈ s) | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear.0.RootPairing.rootFormIn_self_smul_coroot._simp_1_3 | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : 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] (self : RootPairing ι R M N) (i j : ι),
self.coroot ((self.reflectionPerm i) j) =
self.coroot j - (self.toLinearMap (self.root i)) (se... | null | false |
CategoryTheory.Precoverage.RespectsIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Precoverage C → Prop | A precoverage respects isomorphisms if the property of being covering
is stable under isomorphism.
Use `PreZeroHypercover.presieve₀_mem_of_iso` for no universe restrictions. | true |
Complex.equivRealProdAddHom_symm_apply_re | Mathlib.Basic.Complex.Basic | ∀ (p : ℝ × ℝ), (Complex.equivRealProdAddHom.symm p).re = p.1 | null | true |
List.dropPrefix?_eq_some_iff._unary | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {s : List α} (_x : (_ : List α) ×' List α),
_x.1.dropPrefix? _x.2 = some s ↔ ∃ p', _x.1 = p' ++ s ∧ (p' == _x.2) = true | null | false |
Topology.ContinuousMapGeneratedBy.continuousGeneratedBy_iff_uncurry | Mathlib.Topology.Convenient.HomSpace | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [inst_1 : TopologicalSpace Y]
{Z : Type v'} [inst_2 : TopologicalSpace Z] {T : Type v''} [inst_3 : TopologicalSpace T]
[∀ (i : ι), LocallyCompactSpace (X i)] (g : Z → Topology.ContinuousMapGeneratedBy X Y T),
Topology.Continuou... | null | true |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
(S.sup f = ⊥) = ∀ s ∈ S, f s = ⊥ | null | false |
Sylow.normal_of_normalizer_normal | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G),
(Subgroup.normalizer ↑P).Normal → (↑P).Normal | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.coeff_ne_zero_of_lexOrder._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | null | false |
BoxIntegral.Prepartition.splitMany_le_split | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ},
p ∈ s → BoxIntegral.Prepartition.splitMany I s ≤ BoxIntegral.Prepartition.split I p.1 p.2 | null | true |
Filter.EventuallySubset.filter_mono._gcongr_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s t : Set α} {l l' : Filter α}, l' ≤ l → s ≤ᶠ[l] t → s ≤ᶠ[l'] t | null | false |
UInt64.zero_add | Init.Data.UInt.Lemmas | ∀ (a : UInt64), 0 + a = a | null | true |
Submodule.one | Mathlib.Algebra.Algebra.Operations | {R : Type u} → [inst : Semiring R] → {A : Type v} → [inst_1 : Semiring A] → [inst_2 : Module R A] → One (Submodule R A) | `1 : Submodule R A` is the submodule `R ∙ 1` of `A`.
| true |
AlgebraicGeometry.instIsIsoSchemeCoprodComparisonOppositeCommRingCatSpec | Mathlib.AlgebraicGeometry.Limits | ∀ (R S : CommRingCatᵒᵖ), CategoryTheory.IsIso (CategoryTheory.Limits.coprodComparison AlgebraicGeometry.Scheme.Spec R S) | null | true |
LieRingModule.toEnd_apply_apply | Mathlib.Algebra.Lie.Basic | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L) (m : M),
((LieRingModule.toEnd L M) x) m = ⁅x, m⁆ | null | true |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalDiv._sparseCasesOn_32 | Mathlib.Algebra.Order.Field.Basic | {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 |
Lean.CodeAction.FindTacticResult.tactic.elim | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
(t : Lean.CodeAction.FindTacticResult) →
t.ctorIdx = 0 → ((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) → motive t | null | false |
Aesop.BaseRuleSetMember.normForwardRule.sizeOf_spec | Aesop.RuleSet.Member | ∀ (r₁ : Aesop.ForwardRule) (r₂ : Aesop.NormRule),
sizeOf (Aesop.BaseRuleSetMember.normForwardRule r₁ r₂) = 1 + sizeOf r₁ + sizeOf r₂ | null | true |
Complex.cpow_zero | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 0 = 1 | null | true |
Polynomial.root_right_of_root_gcd | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {k : Type y} [inst : Field R] [inst_1 : CommSemiring k] [inst_2 : DecidableEq R] {ϕ : R →+* k}
{f g : Polynomial R} {α : k}, Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0 → Polynomial.eval₂ ϕ α g = 0 | null | true |
Stream'.get_map | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α), (Stream'.map f s).get n = f (s.get n) | null | true |
Subsingleton.intro._flat_ctor | Init.Core | ∀ {α : Sort u}, (∀ (a b : α), a = b) → Subsingleton α | null | false |
Char.toString_eq_singleton | Init.Data.Char.Lemmas | ∀ {c : Char}, c.toString = String.singleton c | null | true |
Ideal.ramificationIdx_eq_of_isGaloisGroup | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (p : Ideal A)
(P Q : Ideal B) [hPp : P.IsPrime] [hp : P.LiesOver p] [hQp : Q.IsPrime] [Q.LiesOver p] (G : Type u_3)
[inst_4 : Group G] [Finite G] [inst_6 : MulSemiringAction G B] [IsGaloisGroup G A B],
P.ramificationI... | All the `Ideal.ramificationIdx` over a fixed maximal ideal are the same. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceMod._regBuiltin.BitVec.reduceMod.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.3044373263._hygCtx._hyg.31 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Lean.Elab.Command.CoinductiveElabData.ref | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax | Ref from the original `InductiveView` | true |
Lean.Lsp.Range.mk.sizeOf_spec | Lean.Data.Lsp.BasicAux | ∀ (start «end» : Lean.Lsp.Position), sizeOf { start := start, «end» := «end» } = 1 + sizeOf start + sizeOf «end» | null | true |
Monotone.mapsTo_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
Monotone f → Set.MapsTo f (Set.Icc a b) (Set.Icc (f a) (f b)) | null | true |
Std.DTreeMap.Internal.Impl.Const.getEntryGE.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α)
(x_3 : Std.DTreeMap.Internal.Impl.leaf.Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.leaf, (compare a k).isGE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryGE k Std.DTreeMap.Internal.Impl.leaf x_3 he = ⋯.elim | null | true |
Std.Do.SPred.Tactic.instHasFrameAndOfSimpAnd_1 | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} (σs : List (Type u_1)) (P P' Q' PQ : Std.Do.SPred σs) [Std.Do.SPred.Tactic.HasFrame P' Q' φ]
[Std.Do.SPred.Tactic.SimpAnd P Q' PQ], Std.Do.SPred.Tactic.HasFrame spred(P ∧ P') PQ φ | null | true |
CategoryTheory.MorphismProperty.Comma.Hom.ctorIdx | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} A} →
{B : Type u_2} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} B} →
{T : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} T} →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B ... | null | false |
CategoryTheory.SymmetricCategory.mk | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[toBraidedCategory : CategoryTheory.BraidedCategory C] →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
Category... | null | true |
AddSubgroup.forall_mem_sup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {C : Type u_2} [inst : AddCommGroup C] {s t : AddSubgroup C} {P : C → Prop},
(∀ x ∈ s ⊔ t, P x) ↔ ∀ x₁ ∈ s, ∀ x₂ ∈ t, P (x₁ + x₂) | null | true |
Homotopy.noConfusion | Mathlib.Algebra.Homology.Homotopy | {P : Sort u_2} →
{ι : Type u_1} →
{V : Type u} →
{inst : CategoryTheory.Category.{v, u} V} →
{inst_1 : CategoryTheory.Preadditive V} →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
{f g : C ⟶ D} →
{t : Homotopy f g} →
{ι... | null | false |
MulAction.IsMinimal.rec | Mathlib.Dynamics.Minimal | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] →
[inst_1 : TopologicalSpace α] →
[inst_2 : MulAction M α] →
{motive : MulAction.IsMinimal M α → Sort u} →
((dense_orbit : ∀ (x : α), Dense (MulAction.orbit M x)) → motive ⋯) →
(t : MulAction.IsMinimal M α) → mot... | null | false |
Complex.equivRealProdLm_symm_apply_im | Mathlib.LinearAlgebra.Complex.Module | ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).im = a.2 | null | true |
Set.mem_ite_empty_right._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (p : Prop) [inst : Decidable p] (t : Set α) (x : α), (x ∈ if p then t else ∅) = (p ∧ x ∈ t) | null | false |
Function.Exact.of_ladder_linearEquiv_of_exact | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} {N : Type u_4} {N' : Type u_5} {P : Type u_6} {P' : Type u_7}
[inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid N'] [inst_5 : AddCommMonoid P] [inst_6 : AddCommMonoid P'] [inst_7 : Module R M]... | null | true |
MeasureTheory.Measure.MutuallySingular.measure_compl_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν), ν h.nullSetᶜ = 0 | null | true |
Topology.IsClosedEmbedding.units_map | Mathlib.Topology.Algebra.Group.Units | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid α] [inst_1 : TopologicalSpace α] [inst_2 : Monoid β]
[inst_3 : TopologicalSpace β] [ContinuousMul α] [T1Space α] {f : α →* β},
Topology.IsClosedEmbedding ⇑f → Topology.IsClosedEmbedding ⇑(Units.map f) | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_11 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)},
S.Exact →
∀ (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1),
CategoryTheory.CategoryStruc... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.FieldNormNum.0.Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusion | Lean.Meta.Tactic.Grind.Arith.FieldNormNum | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.FieldNormNum.Context✝} →
t = t' → Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusionType✝ P t t' | null | false |
MeasureTheory.SimpleFunc.lintegralₗ._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | IsScalarTower ENNReal ENNReal ENNReal | null | false |
isSeqCompact_iff_seqCompactSpace | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_2} [inst : TopologicalSpace E] {A : Set E}, IsSeqCompact A ↔ SeqCompactSpace ↑A | null | true |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Zipper.FinitenessRelation._simp_10 | Std.Data.DTreeMap.Internal.Zipper | ∀ (n : ℕ), (n < n + 1) = True | null | false |
CategoryTheory.Monad.instInhabitedAlgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → (T : CategoryTheory.Monad C) → [Inhabited C] → Inhabited T.Algebra | null | true |
Std.Time.Month.instReprQuarter._aux_1 | Std.Time.Date.Unit.Month | Std.Time.Month.Quarter → ℕ → Std.Format | null | false |
Nat.prod_factorization_pow_eq_self | Mathlib.Data.Nat.Factorization.Defs | ∀ {n : ℕ}, n ≠ 0 → (n.factorization.prod fun x1 x2 => x1 ^ x2) = n | null | true |
Sym | Mathlib.Data.Sym.Basic | Type u_1 → ℕ → Type (max 0 u_1) | The nth symmetric power is n-tuples up to permutation. We define it
as a subtype of `Multiset` since these are well developed in the
library. We also give a definition `Sym.sym'` in terms of vectors, and we
show these are equivalent in `Sym.symEquivSym'`.
| true |
Lean.Server.RefInfo.casesOn | Lean.Server.References | {motive : Lean.Server.RefInfo → Sort u} →
(t : Lean.Server.RefInfo) →
((definition : Option Lean.Server.Reference) →
(usages : Array Lean.Server.Reference) → motive { definition := definition, usages := usages }) →
motive t | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termI₃_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | null | true |
RelSeries.step | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (self : RelSeries r) (i : Fin self.length),
(self.toFun i.castSucc, self.toFun i.succ) ∈ r | Adjacent elements are related | true |
Submonoid.pi_top | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι), (Submonoid.pi I fun i => ⊤) = ⊤ | null | true |
Equiv.Perm.ext | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ | null | true |
Quaternion.normSq_le_zero._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(Quaternion.normSq a ≤ 0) = (a = 0) | null | false |
_private.Mathlib.Basic.Real.Basic.0.Real.inv' | Mathlib.Basic.Real.Basic | ℝ → ℝ | null | true |
Rat.natCast_le_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℕ} {n : ℚ}, (↑m ≤ ↑n) = (↑m ≤ n) | null | false |
ONote._sizeOf_1 | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ | null | false |
_private.Mathlib.FieldTheory.Separable.0.Polynomial.separable_of_subsingleton._simp_1_2 | Mathlib.FieldTheory.Separable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
NonemptyFinLinOrd._sizeOf_1 | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd → ℕ | null | false |
Equiv.vadd | Mathlib.Algebra.Group.TransferInstance | (M : Type u_1) → {α : Type u_2} → {β : Type u_3} → α ≃ β → [VAdd M β] → VAdd M α | Transfer `VAdd` across an `Equiv` | true |
CategoryTheory.ShortComplex.homologyι_naturality | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
Ca... | null | true |
isCoprime_mul_units_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R},
IsUnit u → IsUnit v → ∀ (y z : R), IsCoprime (y * u) (z * v) ↔ IsCoprime y z | null | true |
Path.Homotopy.reflTransSymmAux_mem_I | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (x : ↑unitInterval × ↑unitInterval), Path.Homotopy.reflTransSymmAux x ∈ unitInterval | null | true |
IsStrictOrder.toIsTrans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsStrictOrder α r], IsTrans α r | null | true |
_private.Mathlib.Analysis.Complex.Polynomial.GaussLucas.0.Polynomial.eq_centerMass_of_eval_derivative_eq_zero._simp_1_12 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
CoassocSimps.symm_comp_rid_symm_assoc | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {R : Type u_1} {M : Type u_3} {M' : Type u_6} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
↑(TensorProduct.comm R M' R) ∘ₗ ↑(TensorProduct.rid R M').symm ∘ₗ f = ↑(TensorProduct.lid R M').symm ∘ₗ f | null | true |
Set.powersetCard.addAction_faithful | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α],
1 ≤ n → ↑n < ENat.card α → ∀ {g : G}, AddAction.toPerm g = 1 ↔ AddAction.toPerm g = 1 | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : σ →₀ ℕ)
(φ : MvPowerSeries σ R), f ((MvPowerSeries.coeff n) φ) = (MvPowerSeries.coeff n) ((MvPowerSeries.map f) φ) | null | false |
Set.mapsTo_id | Mathlib.Data.Set.Function | ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s | null | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.isColimitGluedCocone._proof_6 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | null | false |
Std.Time.Week.Offset.toHours | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Hour.Offset | Convert `Week.Offset` into `Hour.Offset`.
| true |
CategoryTheory.Lax.LaxTrans.id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → (F : CategoryTheory.LaxFunctor B C) → CategoryTheory.Lax.LaxTrans F F | The identity lax transformation. | true |
Lean.Elab.Modifiers.mk | Lean.Elab.DeclModifiers | Lean.TSyntax `Lean.Parser.Command.declModifiers →
Option (Lean.TSyntax `Lean.Parser.Command.docComment) →
Lean.Elab.Visibility →
Bool → Lean.Elab.ComputeKind → Lean.Elab.RecKind → Bool → Array Lean.Elab.Attribute → Lean.Elab.Modifiers | null | true |
TensorProduct.leftHasSMul | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R' : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Monoid R'] →
{M : Type u_5} →
{N : Type u_6} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : DistribMulAction R' M] →
[inst_5 : Module R ... | Given two modules over a commutative semiring `R`, if one of the factors carries a
(distributive) action of a second type of scalars `R'`, which commutes with the action of `R`, then
the tensor product (over `R`) carries an action of `R'`.
This instance defines this `R'` action in the case that it is the left module w... | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.mvarsOutputParams.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.PreprocessKind.mvarsOutputParams✝ = 1 | null | true |
CategoryTheory.ShortComplex.Homotopy.refl_h₁ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂), (CategoryTheory.ShortComplex.Homotopy.refl φ).h₁ = 0 | null | true |
DirectLimit.instAddMonoid._proof_6 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
Asymptotics.IsLittleO.sub | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {F : Type u_3} {E' : Type u_4} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ : α → E'}, f₁ =o[l] g → f₂ =o[l] g → (fun x => f₁ x - f₂ x) =o[l] g | null | true |
Int.sub_lt_sub_right_iff._simp_1 | Init.Data.Int.Order | ∀ {a b c : ℤ}, (a - c < b - c) = (a < b) | null | false |
Lean.Grind.NoopConfig.noConfusionType | Init.Grind.Config | Sort u → Lean.Grind.NoopConfig → Lean.Grind.NoopConfig → Sort u | null | false |
_private.Lean.Compiler.LCNF.Simp.DefaultAlt.0.Lean.Compiler.LCNF.Simp.addDefaultAlt.match_7 | Lean.Compiler.LCNF.Simp.DefaultAlt | (motive : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure × ℕ → Sort u_1) →
(x : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure × ℕ) →
((max : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.pure) → (noccs : ℕ) → motive (max, noccs)) → motive x | null | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.tryAutoCongrTheorem?._proof_1 | Lean.Meta.Tactic.Simp.Types | ∀ (__do_lift : Lean.Meta.FunInfo) (config : Lean.Meta.Simp.Config)
(__s : Bool × Bool × Bool × Array Lean.Expr × Array Lean.Meta.Simp.Result × ℕ × Subarray Lean.Meta.CongrArgKind),
config.ground = true ∧ __s.2.2.2.2.2.1 < __do_lift.paramInfo.size → __s.2.2.2.2.2.1 < __do_lift.paramInfo.size | null | false |
_private.Mathlib.Order.Defs.PartialOrder.0.le_antisymm_iff.match_1_1 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} (motive : a ≤ b ∧ b ≤ a → Prop) (x : a ≤ b ∧ b ≤ a),
(∀ (h1 : a ≤ b) (h2 : b ≤ a), motive ⋯) → motive x | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties.0.AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f =
∀ (U : ↑Y.affineOpens) (V : ↑X.affineOpens) (e : ↑V ≤ (TopologicalSpace.Opens.map f.base).obj ↑U),
... | null | false |
Set.singleton_subset_singleton._gcongr_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {a b : α}, a = b → {a} ⊆ {b} | null | false |
USize.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin USize.size), (USize.ofFin x).toNat = ↑x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.