name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Option.merge.eq_4 | Init.Omega.Constraint | ∀ {α : Type u_1} (fn : α → α → α) (x_2 y : α), Option.merge fn (some x_2) (some y) = some (fn x_2 y) | null | true |
SemiRingCat.FilteredColimits.colimitCoconeIsColimit._proof_2 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F),
(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t) 1 = 1 | null | false |
Lean.Server.RequestCancellation._sizeOf_1 | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | null | false |
Lean.Doc.Syntax.metadataContents | Lean.DocString.Syntax | Lean.Parser.Parser | null | true |
Monoid.exponent_multiplicative | Mathlib.GroupTheory.Exponent | ∀ {G : Type u_1} [inst : AddMonoid G], Monoid.exponent (Multiplicative G) = AddMonoid.exponent G | null | true |
ContinuousLinearEquiv.equivLike._proof_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_1} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | false |
Lean.FindLevelMVar.main._unsafe_rec | Lean.Util.FindLevelMVar | (Lean.LMVarId → Bool) → Lean.Expr → Lean.FindLevelMVar.Visitor | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atTop_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | null | false |
CategoryTheory.Enriched.FunctorCategory.homEquiv_apply_π_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F₁ F₂ : CategoryTheory.Functor J C}... | null | true |
FirstCountableTopology.frechetUrysohnSpace | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [FirstCountableTopology X], FrechetUrysohnSpace X | Every first-countable space is a Fréchet-Urysohn space. | true |
instFieldCyclotomicField._aux_34 | Mathlib.NumberTheory.Cyclotomic.Basic | (n : ℕ) → (K : Type u_1) → [inst : Field K] → CyclotomicField n K → CyclotomicField n K → CyclotomicField n K | null | false |
Int.cast_le_neg_one_of_neg | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, a < 0 → ↑a ≤ -1 | null | true |
Array.forall_mem_ne' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (∀ a' ∈ xs, ¬a' = a) ↔ a ∉ xs | null | true |
WithZero.instAddMonoidWithOne | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [AddMonoidWithOne α] → AddMonoidWithOne (WithZero α) | null | true |
Real.RingHom.unique._proof_2 | Mathlib.Algebra.Order.Archimedean.Real.Hom | ∀ (f : ℝ →+* ℝ), { toRingHom := f, monotone' := ⋯ }.toRingHom = default.toRingHom | null | false |
Std.HashMap.keys | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List α | Returns a list of all keys present in the hash map in some order. | true |
lt_of_mul_self_lt_mul_self₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ b → a * a < b * b → a < b | null | true |
Module.piEquiv | Mathlib.LinearAlgebra.StdBasis | (ι : Type u_1) →
(R : Type u_2) →
(M : Type u_3) →
[Finite ι] →
[inst : CommSemiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (ι → M) ≃ₗ[R] (ι → R) →ₗ[R] M | The natural linear equivalence: `Mⁱ ≃ Hom(Rⁱ, M)` for an `R`-module `M`. | true |
Std.Net.IPAddr.family.match_1 | Std.Net.Addr | (motive : Std.Net.IPAddr → Sort u_1) →
(x : Std.Net.IPAddr) →
((addr : Std.Net.IPv4Addr) → motive (Std.Net.IPAddr.v4 addr)) →
((addr : Std.Net.IPv6Addr) → motive (Std.Net.IPAddr.v6 addr)) → motive x | null | false |
DirichletCharacter.convolution_twist_vonMangoldt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N),
(LSeries.convolution ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) fun n => χ ↑n) =
(fun n => χ ↑n) * fun n => Complex.log ↑n | A twisted version of the relation `Λ * ↑ζ = log` in terms of complex sequences. | true |
Orientation.rotationAux._proof_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle) (x y : V),
inner ℝ ((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) x)
((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRota... | null | false |
Lean.Language.Lean.HeaderParsedSnapshot.mk | Lean.Language.Lean.Types | Lean.Language.Snapshot →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Lean.Parser.InputContext →
Lean.Syntax → Option Lean.Language.Lean.HeaderParsedState → Lean.Language.Lean.HeaderParsedSnapshot | null | true |
Valuation.RankLeOne.mk._flat_ctor | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} →
(hom' : (MonoidWithZeroHom.ofClass v).ValueGroup₀ →*₀ NNReal) → StrictMono ⇑hom' → v.RankLeOne | null | false |
LocallyFinite.Realizer.recOn | Mathlib.Data.Analysis.Topology | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
{F : Ctop.Realizer α} →
{f : β → Set α} →
{motive : LocallyFinite.Realizer F f → Sort u} →
(t : LocallyFinite.Realizer F f) →
((bas : (a : α) → { s // a ∈ F.F.f s }) →
(sets : (x : α... | null | false |
ContinuousLinearMap.bilinear_hasTemperateGrowth | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {𝕜 : Type u_2} {D : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_7} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NontriviallyNormedField 𝕜] [NormedAlgebra ℝ 𝕜] [inst_6 : NormedAddCommGroup D] [inst_7 : NormedSpace ℝ D]
[i... | The product of two functions of temperate growth is again of temperate growth.
Version for bilinear maps. | true |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_orderEmbedding_getElem?_eq._simp_1_1 | Mathlib.Data.List.NodupEquivFin | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Tactic.open._regBuiltin.Lean.Parser.Tactic.open.parenthesizer_13 | Lean.Parser.Command | IO Unit | null | false |
AlgebraicGeometry.structurePresheafInModuleCat | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [Module R M] → TopCat.Presheaf (ModuleCat R) (AlgebraicGeometry.PrimeSpectrum.Top R) | The structure presheaf, valued in `ModuleCat`, constructed by dressing up the `Type`-valued
structure presheaf. | true |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'.match_1_11 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : StarMul R] [inst_2 : CommRing S] [inst_3 : Algebra S R]
(u v : ↥(unitary R)) (motive : (∃ y, y • 1 = star ↑v * ↑u) → Prop) (x : ∃ y, y • 1 = star ↑v * ↑u),
(∀ (y : S) (h : y • 1 = star ↑v * ↑u), motive ⋯) → motive x | null | false |
Lean.Grind.ToInt.toInt.eq_1 | Init.GrindInstances.ToInt | ∀ (α : Type u) {range : Lean.Grind.IntInterval} [self : Lean.Grind.ToInt α range], Lean.Grind.ToInt.toInt = self.1 | null | true |
Monoid.CoprodI.Word.equivPair._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] (i : ι) (w : Monoid.CoprodI.Word M),
Monoid.CoprodI.Word.rcons ↑(Monoid.CoprodI.Word.equivPairAux✝ i w) = w | null | false |
Lean.Meta.Try.Collector.OrdSet.set | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Lean.Meta.Try.Collector.OrdSet α → Std.HashSet α | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
CategoryTheory.Bicategory.rightUnitorNatIsoCat_hom_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a b : B) (X : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitorNatIsoCat a b).hom.toNatTrans.app X =
(CategoryTheory.Bicategory.rightUnitor X).hom | null | true |
hasStrictDerivAt_abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt (fun x => |x|) (↑(SignType.sign x)) x | null | true |
DistribSMul.toAddMonoidHom_eq_zsmulAddGroupHom | Mathlib.Algebra.Module.NatInt | ∀ (M : Type u_3) [inst : AddCommGroup M], DistribSMul.toAddMonoidHom M = zsmulAddGroupHom | null | true |
Representation.IntertwiningMap.rTensor_zero | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A... | null | true |
Fin.dfoldrM.loop._sunfold | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.iteratedDerivWithin_tsum_exp_aux_eq._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) | null | false |
WellFounded.partialExtrinsicFix₂_eq_partialExtrinsicFix | Init.WFExtrinsicFix | ∀ {α : Sort u_2} {β : α → Sort u_3} {C₂ : (a : α) → β a → Sort u_1} [inst : ∀ (a : α) (b : β a), Nonempty (C₂ a b)]
{R : (a : α) ×' β a → (a : α) ×' β a → Prop}
{F : (a : α) → (b : β a) → ((a' : α) → (b' : β a') → R ⟨a', b'⟩ ⟨a, b⟩ → C₂ a' b') → C₂ a b} {a : α} {b : β a},
Acc R ⟨a, b⟩ →
WellFounded.partialExt... | null | true |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_6, u_3} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) (A : Type u_5) [inst_2 : CategoryTheory.Category.{u_2, u_5} A]
[inst_3 : G.LocallyCoverDense K] [inst_4 : G.IsL... | null | false |
Configuration.Nondegenerate.exists_line | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.Nondegenerate P L] (p : P), ∃ l, p ∉ l | null | true |
matPolyEquiv_symm_map_eval | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Polynomial (Matrix n n R)) (r : R),
(matPolyEquiv.symm M).map (Polynomial.eval r) = Polynomial.eval ((Matrix.scalar n) r) M | null | true |
CategoryTheory.Functor.Final.coconesEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_4}
[inst_3 : CategoryTheory.Category.{u_2, u_4} E] (G : CategoryTheory.Functor D E)
{X Y : CategoryTheory.Limits.Cocone (F.c... | null | false |
MonoidWithZero.toOppositeMulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | (M₀ : Type u_2) → [inst : MonoidWithZero M₀] → MulActionWithZero M₀ᵐᵒᵖ M₀ | Like `MonoidWithZero.toMulActionWithZero`, but multiplies on the right. See also
`Semiring.toOppositeModule` | true |
Nat.EqResult.eq.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (x y p x_1 y_1 p_1 : Lean.Expr), (Nat.EqResult.eq x y p = Nat.EqResult.eq x_1 y_1 p_1) = (x = x_1 ∧ y = y_1 ∧ p = p_1) | null | true |
ContMDiffMap.restrictMonoidHom._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_3}
[inst_5 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {H' : Type u_6} [inst_6 : Topologi... | null | false |
Module.Basis.dualBasis_coord_toDualEquiv_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (i : ι) (f : M),
(b.dualBasis.coord i) (b.toDualEquiv f) = (b.coord i) f | null | true |
Lean.Parser.Module.module.formatter | Lean.Parser.Module.Syntax | Lean.PrettyPrinter.Formatter | null | true |
Module.Basis.noConfusionType | Mathlib.LinearAlgebra.Basis.Defs | Sort u →
{ι : Type u_1} →
{R : Type u_3} →
{M : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
Module.Basis ι R M →
{ι' : Type u_1} →
{R' : Type u_3} →
{M' : Type u_6} →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.minKey!_eq._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 |
Std.Internal.List.getValueCast_alterKey._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (k k' : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k' (Std.Internal.List.alterKey k f l) = true →
(k == k') = true → (f (Std.Internal.List.getVal... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
mellinConvergent_of_isBigO_rpow_exp | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ},
0 < a →
∀ {f : ℝ → E} {s : ℂ},
MeasureTheory.LocallyIntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(f =O[Filter.atTop] fun t => Real.exp (-a * t)) →
(f =O[nhdsWithin 0 (Set.Ioi 0)] fun x => x ^ (-b)) → ... | If `f` is locally integrable, decays exponentially at infinity, and is `O(x ^ (-b))` at 0, then
its Mellin transform converges for `b < s.re`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.w_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ),
FermatLastTheoremForThreeGen.Solution'.c✝ (FermatLastTheoremForThreeGen.Solution.toSolution'✝ S) =
(hζ.toInteger - 1) ^ FermatLastTheoremForThreeGen.Solution.multiplicity✝ S *
FermatLastTheo... | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.Consumer.ctorIdx | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded.Consumer✝ α → ℕ | null | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.casesExpand.match_19 | Batteries.CodeAction.Misc | (motive : Option (Array (Lean.Name × Array Lean.Name)) → Sort u_1) →
(__discr : Option (Array (Lean.Name × Array Lean.Name))) →
((ctors : Array (Lean.Name × Array Lean.Name)) → motive (some ctors)) →
((x : Option (Array (Lean.Name × Array Lean.Name))) → motive x) → motive __discr | null | false |
Colex.instSMul'.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {x : Type u_2} {x_1 : Type u_1} [inst : SMul x x_1], Colex.instSMul' = inst | null | true |
AddAction.stabilizerEquivStabilizer_trans | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a),
k = h + g →
(AddAction.stabilizerEquivStabilizer hg).trans (AddAction.stabilizerEquivStabilizer hh) =
AddAction.stabilizerEquivStabilizer hk | null | true |
Lean.Meta.Grind.SymbolPriorityEntry.mk.noConfusion | Lean.Meta.Tactic.Grind.EMatchTheorem | {P : Sort u} →
{declName : Lean.Name} →
{prio : ℕ} →
{declName' : Lean.Name} →
{prio' : ℕ} →
{ declName := declName, prio := prio } = { declName := declName', prio := prio' } →
(declName = declName' → prio = prio' → P) → P | null | false |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.asiegel.eq_1 | Mathlib.NumberTheory.NumberField.House | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {α : Type u_2} {β : Type u_3}
(a : Matrix α β (NumberField.RingOfIntegers K)) (k : α × (K →+* ℂ)) (l : β × (K →+* ℂ)),
NumberField.house.asiegel✝ K a k l = NumberField.house.a'✝ K a k.1 l.1 l.2 k.2 | null | true |
BoundedOrderHomClass.toBotHomClass | Mathlib.Order.Hom.Bounded | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : LE α] [inst_2 : LE β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedOrderHomClass F α β], BotHomClass F α β | null | true |
_private.Mathlib.Topology.UniformSpace.Defs.0.UniformSpace.hasBasis_nhds._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Con.congr.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M} (h : c = d),
Con.congr h = { toEquiv := Quotient.congr (Equiv.refl M) ⋯, map_mul' := ⋯ } | null | true |
Nat.le_sqrt | Mathlib.Data.Nat.Sqrt | ∀ {m n : ℕ}, m ≤ n.sqrt ↔ m * m ≤ n | null | true |
Std.Iterators.Types.Zip.instFinite₂ | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type w → Type w'} {α₁ β₁ : Type w} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type w} [inst_1 : Std.Iterator α₂ m β₂]
[inst_2 : Monad m] [Std.Iterators.Productive α₁ m] [Std.Iterators.Finite α₂ m],
Std.Iterators.Finite (Std.Iterators.Types.Zip α₁ m α₂ β₂) m | null | true |
Std.TransCmp.lt_of_eq_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.lt → cmp a c = Ordering.lt | null | true |
List.insert_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, a ∉ l → List.insert a l = a :: l | null | true |
_private.Init.Data.Int.LemmasAux.0.Int.sub_max_sub_left._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬max (a - b) (a - c) = a - min b c → False | null | false |
Real.denselyNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (x x_1 : ℝ), 0 ≤ x → x < x_1 → ∃ a, x < ‖a‖ ∧ ‖a‖ < x_1 | null | false |
Int.lt_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a < b → b ≤ c → a < c | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.pendingConsumer | Std.Http.Data.Body.Stream | Std.Http.Body.Channel.State✝ → Option Std.Http.Body.Channel.Consumer✝ | A single blocked consumer waiting for a producer.
| true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.at_least_as_long_as_coind._simp_1_8 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α), (s = Stream'.Seq.nil) = (s.length' = 0) | null | false |
Qq.SortLocalDecls.State.ctorIdx | Qq.SortLocalDecls | Qq.SortLocalDecls.State → ℕ | null | false |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | {α : outParam (Type u)} →
{β : outParam (Type v)} →
{inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} →
{σ : Type w} →
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} →
[self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] → σ → Prop | A predicate that indicates whether a formula can soundly be passed into performRatAdd. | true |
CategoryTheory.Limits.fiberwiseColimitLimitIso._proof_12 | Mathlib.CategoryTheory.Limits.Preserves.Grothendieck | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {H : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} H] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{F : CategoryTheory.Functor C CategoryTheory.Cat}
(K : CategoryTheory.Functor J (CategoryTheory.Functor (CategoryTheory.Groth... | null | false |
StrictMonoOn.mapsTo_Ioc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : PartialOrder α] [inst_1 : Preorder β] {a b : α},
StrictMonoOn f (Set.Icc a b) → Set.MapsTo f (Set.Ioc a b) (Set.Ioc (f a) (f b)) | null | true |
AlgHom.card_le | Mathlib.FieldTheory.Fixed | ∀ {F : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K]
[inst_3 : FiniteDimensional F K], Fintype.card (K →ₐ[F] K) ≤ Module.finrank F K | null | true |
_private.Init.Data.String.Iterate.0.String.Slice.ByteIterator.finitenessRelation._proof_2 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1},
WellFounded
(InvImage WellFoundedRelation.rel fun it => it.internalState.s.utf8ByteSize - it.internalState.offset.byteIdx) | null | false |
CategoryTheory.finrank_hom_simple_simple_le_one | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (𝕜 : Type u_2)
[inst_2 : Field 𝕜] [IsAlgClosed 𝕜] [inst_4 : CategoryTheory.Linear 𝕜 C] [CategoryTheory.Limits.HasKernels C] (X Y : C)
[FiniteDimensional 𝕜 (X ⟶ X)] [CategoryTheory.Simple X] [CategoryTheory.Si... | **Schur's lemma** for `𝕜`-linear categories:
if hom spaces are finite dimensional, then the hom space between simples is at most 1-dimensional.
See `finrank_hom_simple_simple_eq_one_iff` and `finrank_hom_simple_simple_eq_zero_iff` below
for the refinements when we know whether or not the simples are isomorphic.
| true |
Lean.Meta.Grind.instHasAnchorSplitCandidateWithAnchor | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.HasAnchor Lean.Meta.Grind.SplitCandidateWithAnchor | null | true |
DyckWord.firstReturn.eq_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord),
p.firstReturn =
List.findIdx
(fun i => decide (List.count DyckStep.U (List.take (i + 1) ↑p) = List.count DyckStep.D (List.take (i + 1) ↑p)))
(List.range (↑p).length) | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKeyD k fallback = fallback | null | true |
Asymptotics.isBigOTVS_fun_neg_right._simp_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | null | false |
AddSubgroup.card_dvd_of_injective | Mathlib.GroupTheory.Coset.Card | ∀ {α : Type u_1} [inst : AddGroup α] {H : Type u_2} [inst_1 : AddGroup H] (f : α →+ H),
Function.Injective ⇑f → Nat.card α ∣ Nat.card H | null | true |
AddOpposite.forall | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {p : αᵃᵒᵖ → Prop}, (∀ (a : αᵃᵒᵖ), p a) ↔ ∀ (a : α), p (AddOpposite.op a) | null | true |
OrderHom.apply | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → α → (α →o β) →o β | Function application `fun f => f a` (for fixed `a`) is a monotone function from the
monotone function space `α →o β` to `β`. See also `Pi.evalOrderHom`. | true |
Manifold.«_aux_Mathlib_Geometry_Manifold_Instances_Real___macroRules_Manifold_term𝓡∂__1» | Mathlib.Geometry.Manifold.Instances.Real | Lean.Macro | null | false |
CompleteDistribLattice.toHNot | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → HNot α | null | true |
ProbabilityTheory.iIndepSets.piiUnionInter_of_notMem | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {π : ι → Set (Set Ω)} {a : ι}
{S : Finset ι}, ProbabilityTheory.iIndepSets π μ → a ∉ S → ProbabilityTheory.IndepSets (piiUnionInter π ↑S) (π a) μ | null | true |
_private.Mathlib.NumberTheory.LegendreSymbol.AddCharacter.0.AddChar.val_mem_rootsOfUnity._simp_1_1 | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (↑ζ ^ k = 1) | null | false |
Lean.Language.Lean.CommandParsedSnapshot.brecOn_3.eq | Lean.Language.Lean.Types | ∀ {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u}
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_4 : Task Lean.Language.Lean.CommandParsedSnapshot → ... | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.noConfusion | Mathlib.Tactic.GRewrite.Core | {P : Sort u} →
{t t' : Mathlib.Tactic.GRewrite.GRewriteLemma✝} →
t = t' → Mathlib.Tactic.GRewrite.GRewriteLemma.noConfusionType✝ P t t' | null | false |
_private.Std.Http.Internal.String.0.Std.Http.Internal.UnquoteState.done | Std.Http.Internal.String | String → Std.Http.Internal.UnquoteState✝ | null | true |
MeasurableEquiv.piFinSuccAbove_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_8) [inst : (i : Fin (n + 1)) → MeasurableSpace (α i)] (i : Fin (n + 1)),
⇑(MeasurableEquiv.piFinSuccAbove α i) = ⇑(Fin.insertNthEquiv α i).symm | null | true |
Real.logb_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, Real.logb b 0 = 0 | null | true |
LieAlgebra.radical_eq_top_of_isSolvable | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.IsSolvable L], LieAlgebra.radical R L = ⊤ | null | true |
String.all_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.all s p = true ↔ ∀ c ∈ s.toList, p c = true | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_lt._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool} {s : ℕ},
i < (List.findIdxs p xs s).length → 0 < (List.findIdxs p xs s).length | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.