name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1.recOn | Lean.Server.FileWorker.WidgetRequests | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
(t : Lean.Widget.RpcEncodablePacket✝) →
((type exprExplicit doc : Lean.Json) → motive { type := type, exprExplicit := exprExplicit, doc := doc }) → motive t | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Decl.isExtern._sparseCasesOn_1 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(t : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(xs : Array Lean.IR.Param) →
(type : Lean.IR.IRType) → (ext : Lean.ExternAttrData) → motive (Lean.IR.Decl.extern f xs type ext)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Group.rank | Mathlib.GroupTheory.Rank | (G : Type u_1) → [inst : Group G] → [h : Group.FG G] → ℕ | true |
Finset.mem_neg_vadd_finset_iff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : AddGroup α] [inst_2 : AddAction α β] {s : Finset β}
{a : α} {b : β}, b ∈ -a +ᵥ s ↔ a +ᵥ b ∈ s | true |
List.modifyHead_eq_nil_iff._simp_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α}, (List.modifyHead f l = []) = (l = []) | false |
Lean.Parser.registerBuiltinParserAttribute._auto_1 | Lean.Parser.Extension | Lean.Syntax | false |
Complex.VerticalIntegrable._auto_1 | Mathlib.Analysis.MellinTransform | Lean.Syntax | false |
Int.sign_one | Init.Data.Int.Order | Int.sign 1 = 1 | true |
CategoryTheory.Equivalence.instMonoidalInverseRefl._aux_1 | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶
CategoryTheory.Equivalence.refl.inverse.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) | false |
DerivingHelpers._aux_Init_LawfulBEqTactics___macroRules_DerivingHelpers_tacticDeriving_ReflEq_tactic_1 | Init.LawfulBEqTactics | Lean.Macro | false |
CategoryTheory.ComposableArrows.Precomp.map_zero_succ_succ._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (j : ℕ), 0 ≤ j + 1 | false |
Lean.Parser.LeadingIdentBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.LeadingIdentBehavior → Lean.Parser.LeadingIdentBehavior → Sort v✝ | true |
Prefunctor.IsCovering.symmetrify | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V),
φ.IsCovering → φ.symmetrify.IsCovering | true |
IsCompactOperator.hasEigenvalue_iff_mem_spectrum | Mathlib.Analysis.Normed.Operator.FredholmAlternative | ∀ {𝕜 : Type u_1} {X : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {T : X →L[𝕜] X} {μ : 𝕜} [CompleteSpace X],
IsCompactOperator ⇑T → μ ≠ 0 → (Module.End.HasEigenvalue (↑T) μ ↔ μ ∈ spectrum 𝕜 T) | true |
PowerSeries.«term_%ʷ_» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.TrailingParserDescr | true |
Dilation.ratioHom | Mathlib.Topology.MetricSpace.Dilation | {α : Type u_1} → [inst : PseudoEMetricSpace α] → (α →ᵈ α) →* NNReal | true |
irrational_ratCast_add_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {q : ℚ} {x : ℝ}, Irrational (↑q + x) ↔ Irrational x | true |
MeasurableEquiv.shearAddRight | Mathlib.MeasureTheory.Group.Prod | (G : Type u_1) →
[inst : MeasurableSpace G] → [inst_1 : AddGroup G] → [MeasurableAdd₂ G] → [MeasurableNeg G] → G × G ≃ᵐ G × G | true |
lie_abelian_iff_equiv_lie_abelian | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), IsLieAbelian L₁ ↔ IsLieAbelian L₂ | true |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscrete_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S : Set X},
(S ∈ Filter.codiscrete X) = ∀ (x : X), Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal Sᶜ) | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.instEffectiveEpiComp.match_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | (motive : Unit → Sort u_1) → (x : Unit) → (Unit → motive PUnit.unit) → motive x | false |
Lean.Grind.CommRing.Poly.NonnegCoeffs.below.casesOn | Init.Grind.Ring.CommSemiringAdapter | ∀ {motive : (a : Lean.Grind.CommRing.Poly) → a.NonnegCoeffs → Prop}
{motive_1 :
{a : Lean.Grind.CommRing.Poly} → (t : a.NonnegCoeffs) → Lean.Grind.CommRing.Poly.NonnegCoeffs.below t → Prop}
{a : Lean.Grind.CommRing.Poly} {t : a.NonnegCoeffs} (t_1 : Lean.Grind.CommRing.Poly.NonnegCoeffs.below t),
(∀ (c : ℤ) (a... | false |
UniqueDiffWithinAt.inter' | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
UniqueDiffWithinAt 𝕜 s x → t ∈ nhdsWithin x s → UniqueDiffWithinAt 𝕜 (s ∩ t) x | true |
Polynomial.Monic.pow | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (n : ℕ), (p ^ n).Monic | true |
WithLp.noConfusion | Mathlib.Analysis.Normed.Lp.WithLp | {P : Sort u} →
{p : ENNReal} →
{V : Type u_1} →
{t : WithLp p V} →
{p' : ENNReal} →
{V' : Type u_1} → {t' : WithLp p' V'} → p = p' → V = V' → t ≍ t' → WithLp.noConfusionType P t t' | false |
instPreorderShrink | Mathlib.Order.Shrink | {α : Type u_1} → [inst : Small.{u, u_1} α] → [Preorder α] → Preorder (Shrink.{u, u_1} α) | true |
Mathlib.Tactic.ToDual.initFn._@.Mathlib.Tactic.Translate.ToDual.394485197._hygCtx._hyg.2 | Mathlib.Tactic.Translate.ToDual | IO Unit | false |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.interSmallerFn.match_1 | Std.Data.DHashMap.Internal.Defs | {α : Type u_2} →
{β : α → Type u_1} →
(motive : Option ((a : α) × β a) → Sort u_3) →
(x : Option ((a : α) × β a)) → ((kv' : (a : α) × β a) → motive (some kv')) → (Unit → motive none) → motive x | false |
Multiset.exists_multiset_eq_map_quot_mk | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {r : α → α → Prop} (s : Multiset (Quot r)), ∃ t, s = Multiset.map (Quot.mk r) t | true |
CliffordAlgebra.reverse_mem_evenOdd_iff._simp_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
(CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n) = (x ∈ CliffordAlgebra.evenOdd Q n) | false |
CommGroup.monoidHomMonoidHomEquiv._proof_5 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_2) (M : Type u_1) [inst : CommGroup G] [inst_1 : CommMonoid M] (g : G), 1 g = 1 | false |
FractionalIdeal.coeIdeal_inj | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_3} [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{I J : Ideal R}, ↑I = ↑J ↔ I = J | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.supp_injective._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | false |
Std.Time.OffsetO | Std.Time.Format.Basic | Type | true |
QuotientGroup.Quotient.group._proof_13 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal],
autoParam
(∀ (n : ℕ) (a : G ⧸ N),
QuotientGroup.Quotient.group._aux_9 N (Int.negSucc n) a = (QuotientGroup.Quotient.group._aux_9 N (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam | false |
CategoryTheory.Limits.biprod.lift_desc_assoc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] {T U : C} {f : T ⟶ X} {g : T ⟶ Y} {h : X ⟶ U} {i : Y ⟶ U}
{Z : C} (h_1 : U ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift ... | true |
inl_coprodIsoPushout_hom_assoc | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasInitial C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] (X Y : C) [inst_3 : CategoryTheory.Limits.HasBinaryCoproduct X Y]
{Z : C}
(h : CategoryTheory.Limits.pushout (CategoryTheory.Limits.initial.to X) (CategoryTheory.Li... | true |
CategoryTheory.Bicategory.whiskerLeftIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
(f : a ⟶ b) →
{g h : b ⟶ c} → (g ≅ h) → (CategoryTheory.CategoryStruct.comp f g ≅ CategoryTheory.CategoryStruct.comp f h) | true |
CategoryTheory.MonoidalCategory.DayConvolution.isPointwiseLeftKanExtensionUnit | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
(F G : CategoryTheory.Functor C V) →
[self :... | true |
CategoryTheory.ShortComplex.Homotopy.ofEq._proof_10 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂},
φ₁ = φ₂ → φ₁.τ₃ = 0 + CategoryTheory.CategoryStruct.comp 0 S₂.g + φ₂.τ₃ | false |
Lean.Firefox.ProfileMeta.product._default | Lean.Util.Profiler | String | false |
IsPrimitiveRoot.integralPowerBasis_dim | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.integralPowerBasis.dim = n.totient | true |
curveIntegral | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | {𝕜 : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → {a b : E} → (E → E →L[𝕜] F) → Path a b → F | true |
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.Solution.tensor.match_1.splitter | Mathlib.Algebra.Module.Presentation.Tensor | {A : Type u_5} →
[inst : CommRing A] →
{relations₁ : Module.Relations A} →
{relations₂ : Module.Relations A} →
(motive : (relations₁.tensor relations₂).G → Sort u_6) →
(x : (relations₁.tensor relations₂).G) →
((g₁ : relations₁.G) → (g₂ : relations₂.G) → motive (g₁, g₂)) → motiv... | true |
termSudoSet_option___In_ | Mathlib.Tactic.SudoSetOption | Lean.ParserDescr | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_one_add_div_one_sub._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
_private.Mathlib.CategoryTheory.Pi.Basic.0.CategoryTheory.Pi.sumElimCategory.match_5.splitter | Mathlib.CategoryTheory.Pi.Basic | {I J : Type u_1} →
(motive : I ⊕ J → Sort u_2) → (x : I ⊕ J) → ((i : I) → motive (Sum.inl i)) → ((j : J) → motive (Sum.inr j)) → motive x | true |
String.front_eq | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.front s = s.toList.headD default | true |
Metric.ediam_pi_le_of_le | Mathlib.Topology.EMetricSpace.Diam | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → PseudoEMetricSpace (X i)]
{s : (i : ι) → Set (X i)} {c : ENNReal}, (∀ (b : ι), Metric.ediam (s b) ≤ c) → Metric.ediam (Set.univ.pi s) ≤ c | true |
DenseRange.zpow_of_ergodic_mul_left | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[OpensMeasurableSpace G] {μ : MeasureTheory.Measure G} [μ.IsOpenPosMeasure] {g : G},
Ergodic (fun x => g * x) μ → DenseRange fun x => g ^ x | true |
CategoryTheory.Sigma.descUniq_inv_app | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (F : (i : I) → CategoryTheory.Functor (C i) D)
(q : CategoryTheory.Functor ((i : I) × C i) D) (h : (i : I) → (CategoryTheory.Sigma.incl i).comp q ≅ F i) (i : I)
(... | true |
groupCohomology.isMulCoboundary₁_of_isMulCocycle₁_of_aut_to_units | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
(f : Gal(L/K) → Lˣ), groupCohomology.IsMulCocycle₁ f → groupCohomology.IsMulCoboundary₁ f | true |
continuousOn_union_iff_of_isOpen | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s t : Set α} {f : α → β},
IsOpen s → IsOpen t → (ContinuousOn f (s ∪ t) ↔ ContinuousOn f s ∧ ContinuousOn f t) | true |
Finmap.lookup_toFinmap | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
Finmap.lookup a s.toFinmap = AList.lookup a s | true |
Unitary.mulRight_apply | Mathlib.Analysis.CStarAlgebra.Unitary.Maps | ∀ (R : Type u_1) {A : Type u_2} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : CStarRing A] [inst_3 : Ring R]
[inst_4 : Module R A] [inst_5 : IsScalarTower R A A] (u : ↥(unitary A)) (x : A), (Unitary.mulRight R u) x = x * ↑u | true |
AffineSubspace.instNontrivial | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], Nontrivial (AffineSubspace k P) | true |
IsStarNormal.recOn | Mathlib.Algebra.Star.SelfAdjoint | {R : Type u_1} →
[inst : Mul R] →
[inst_1 : Star R] →
{x : R} →
{motive : IsStarNormal x → Sort u} →
(t : IsStarNormal x) → ((star_comm_self : Commute (star x) x) → motive ⋯) → motive t | false |
AugmentedSimplexCategory.inl'_eval | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y : SimplexCategory) (i : Fin (x.len + 1)),
(SimplexCategory.Hom.toOrderHom (AugmentedSimplexCategory.inl' x y)) i = Fin.cast ⋯ (Fin.castAdd (y.len + 1) i) | true |
Quiver.reverse | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_4} → [inst : Quiver V] → [Quiver.HasReverse V] → {a b : V} → (a ⟶ b) → (b ⟶ a) | true |
Std.Time.PlainDateTime.toPlainTime | Std.Time.DateTime | Std.Time.PlainDateTime → Std.Time.PlainTime | true |
Parser.Attr.mfld_simps_proc | Mathlib.Tactic.Attr.Register | Lean.ParserDescr | true |
CategoryTheory.RetractArrow.right_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.right.i = h.i.right | true |
ENat.floor_le._simp_1 | Mathlib.Algebra.Order.Floor.Extended | ∀ {r : ENNReal} {n : ℕ∞}, n ≠ ⊤ → (⌊r⌋ₑ ≤ n) = (r < ↑n + 1) | false |
Nat.isCompl_even_odd | Mathlib.Algebra.Order.Ring.Nat | IsCompl {n | Even n} {n | Odd n} | true |
_private.Mathlib.CategoryTheory.Sites.Hypercover.Zero.0.CategoryTheory.Precoverage.RespectsIso.of_forall_exists_iso.match_1_7 | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {S : C} {R T : CategoryTheory.Presieve S}
(YR : ⦃Z : C⦄ → (g : Z ⟶ S) → R g → C) (eR : ⦃Z : C⦄ → (g : Z ⟶ S) → (a : R g) → YR g a ≅ Z),
let F :=
{ I₀ := ↑R.uncurry ⊕ ↑T.uncurry, X := fun i => Sum.elim (fun j => YR (↑j).snd ⋯) (fun j => (↑j).fst) i,
... | false |
Subspace.orderIsoFiniteCodimDim._proof_5 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ),
Module.Finite K ↥(Submodule.dualAnnihilator ↑⟨Submodule.dualCoannihilator ↑(OrderDual.ofDual W), ⋯⟩) | false |
Metric.eventually_notMem_thickening_of_infEDist_pos | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {E : Set α} {x : α},
x ∉ closure E → ∀ᶠ (δ : ℝ) in nhds 0, x ∉ Metric.thickening δ E | true |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_term__¹_1» | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro | false |
PosNum.shiftl | Mathlib.Data.Num.Bitwise | PosNum → ℕ → PosNum | true |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.hasBasis_nhds_zero.match_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_2} {R : Type u_1} [inst : Ring R] (motive : TwoSidedIdeal R × (σ →₀ ℕ) → Prop)
(h : TwoSidedIdeal R × (σ →₀ ℕ)), (∀ (I : TwoSidedIdeal R) (d : σ →₀ ℕ), motive (I, d)) → motive h | false |
CategoryTheory.Limits.Cone.functoriality.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D),
CategoryTheory.Limits.Cone.functoriality F G =
{ obj := fun A =... | true |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.one_sub_eta_logDeriv_eq | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ (z : ℂ) (n : ℕ),
logDeriv (fun x => 1 - ModularForm.eta_q n x) z =
2 * ↑Real.pi * Complex.I * (↑n + 1) * -ModularForm.eta_q n z / (1 - ModularForm.eta_q n z) | true |
CategoryTheory.Over.map_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X Y : T} {f : X ⟶ Y} {U V : CategoryTheory.Over X}
{g : U ⟶ V}, ((CategoryTheory.Over.map f).map g).left = g.left | true |
_private.Lean.Meta.Tactic.CasesOnStuckLHS.0.Lean.Meta.casesOnStuckLHS?.match_1 | Lean.Meta.Tactic.CasesOnStuckLHS | (motive : DoResultPR (Array Lean.MVarId) (Option (Array Lean.MVarId)) PUnit.{1} → Sort u_1) →
(r : DoResultPR (Array Lean.MVarId) (Option (Array Lean.MVarId)) PUnit.{1}) →
((a : Array Lean.MVarId) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Option (Array Lean.MVarId)) → (u : PUnit.{1}) → motiv... | false |
_private.Mathlib.Algebra.Group.Prod.0.Prod.instCancelMonoid._simp_3 | Mathlib.Algebra.Group.Prod | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | false |
Std.DTreeMap.Const.getD_ofList_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.ofList l cmp) k fallback = fallback | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.mkGetLsbD.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | (motive : Option Lean.Expr → Sort u_1) →
(__discr : Option Lean.Expr) →
((subProof : Lean.Expr) → motive (some subProof)) → ((x : Option Lean.Expr) → motive x) → motive __discr | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVLogicalCache.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → Sort u_1) →
(x : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical)) →
((hit : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) → motive (some hit)) →
(Unit → motive none) → motive x | false |
Mathlib.Tactic.AtomM.Recurse.Config.zetaDelta | Mathlib.Util.AtomM.Recurse | Mathlib.Tactic.AtomM.Recurse.Config → Bool | true |
Std.DTreeMap.Internal.Impl.insertMin!._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → (k : α) → β k → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey_beq._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {o : Option α} {a : α}, (o = some a) = ∃ (h : o.isSome = true), o.get h = a | false |
Std.Net.SocketAddressV6.mk.noConfusion | Std.Net.Addr | {P : Sort u} →
{addr : Std.Net.IPv6Addr} →
{port : UInt16} →
{addr' : Std.Net.IPv6Addr} →
{port' : UInt16} →
{ addr := addr, port := port } = { addr := addr', port := port' } → (addr = addr' → port = port' → P) → P | false |
CategoryTheory.Abelian.SpectralObject.zero₂ | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ :... | true |
_private.Mathlib.NumberTheory.ModularForms.NormTrace.0.ModularForm.eq_const_of_weight_zero₀._simp_1_6 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
IO.Process.SpawnArgs.inheritEnv._default | Init.System.IO | Bool | false |
PartialEquiv.trans' | Mathlib.Logic.Equiv.PartialEquiv | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} → (e : PartialEquiv α β) → (e' : PartialEquiv β γ) → e.target = e'.source → PartialEquiv α γ | true |
Std.Internal.IO.Process.ResourceUsageStats.messagesSent | Std.Internal.Async.Process | Std.Internal.IO.Process.ResourceUsageStats → UInt64 | true |
Perfection.instCommSemiring._proof_21 | Mathlib.RingTheory.Perfection | ∀ (R : Type u_1) [inst : CommSemiring R], AddSubmonoidClass (Subsemiring (ℕ → R)) (ℕ → R) | false |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.multipliableLocallyUniformlyOn_eta._simp_1_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a : E), (0 ≤ ‖a‖) = True | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} → F.PreOneHypercoverDenseData X → CategoryTheory.Limits.MulticospanShape | true |
FiberBundleCore.rec | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_5} →
{B : Type u_6} →
[inst : TopologicalSpace B] →
{F : Type u_7} →
[inst_1 : TopologicalSpace F] →
{motive : FiberBundleCore ι B F → Sort u} →
((baseSet : ι → Set B) →
(isOpen_baseSet : ∀ (i : ι), IsOpen (baseSet i)) →
(indexAt : ... | false |
Asymptotics.IsEquivalent.mono | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {l : Filter α} {f g : α → β} {l' : Filter α},
Asymptotics.IsEquivalent l' f g → l ≤ l' → Asymptotics.IsEquivalent l f g | true |
Sylow.noConfusionType | Mathlib.GroupTheory.Sylow | Sort u →
{p : ℕ} →
{G : Type u_1} →
[inst : Group G] → Sylow p G → {p' : ℕ} → {G' : Type u_1} → [inst' : Group G'] → Sylow p' G' → Sort u | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.mkClosureForAux._unsafe_rec | Lean.Elab.MutualDef | Array Lean.FVarId → StateRefT' IO.RealWorld Lean.Elab.Term.MutualClosure.ClosureState Lean.Elab.TermElabM Unit | false |
Distribution.IsVanishingOn.disjoint_dsupport | Mathlib.Analysis.Distribution.Support | ∀ {α : Type u_2} {β : Type u_3} {F : Type u_6} {V : Type u_10} [inst : FunLike F α β] [inst_1 : TopologicalSpace α]
[inst_2 : Zero β] [inst_3 : Zero V] {f : F → V} {s : Set α},
Distribution.IsVanishingOn f s → IsOpen s → Disjoint s (Distribution.dsupport f) | true |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.elabInsertCastAux | Mathlib.Tactic.Translate.TagUnfoldBoundary | Lean.Name →
Mathlib.Tactic.Translate.CastKind✝ →
Lean.Term → Mathlib.Tactic.Translate.TranslateData → Lean.Elab.Command.CommandElabM (Lean.Name × Lean.Name) | true |
CategoryTheory.Triangulated.TStructure.isIso_truncLE_map_iff | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
Quotient.outRelEmbedding_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {x : Setoid α} {r : α → α → Prop} (H : ∀ (a₁ b₁ a₂ b₂ : α), a₁ ≈ a₂ → b₁ ≈ b₂ → r a₁ b₁ = r a₂ b₂)
(a : Quotient x), (Quotient.outRelEmbedding H) a = a.out | true |
ContinuousLinearMap.coprod_apply | Mathlib.Topology.Algebra.Module.LinearMapPiProd | ∀ {R : Type u_1} {M : Type u_3} {M₁ : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M₁] [inst_3 : TopologicalSpace M₂] [inst_4 : AddCommMonoid M] [inst_5 : Module R M]
[inst_6 : ContinuousAdd M] [inst_7 : AddCommMonoid M₁] [inst_8 : Module R M₁] [inst_9 : Add... | true |
Std.HashMap.getKey!_union_of_not_mem_left | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [inst : Inhabited α] [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∪ m₂).getKey! k = m₂.getKey! k | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.