name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Multiset.noncommProd | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} → [inst : Monoid α] → (s : Multiset α) → {x | x ∈ s}.Pairwise Commute → α |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0.ModularFormClass.qExpansion_coeff_eq_intervalIntegral._simp_1_14 | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
CategoryTheory.InjectiveResolution.Hom.recOn | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{I : CategoryTheory.InjectiveResolution Z} →
{Z' : C} →
{I' : CategoryTheory.InjectiveResolution Z'} →
{f : Z ⟶ Z'} →
{motive : I.Hom I' f → Sort u_1} →
(t : I.Hom I' f) →
((hom : I.cocomplex ⟶ I'.cocomplex) →
(ι_f_zero_comp_hom_f_zero :
CategoryTheory.CategoryStruct.comp (I.ι.f 0) (hom.f 0) =
CategoryTheory.CategoryStruct.comp (((CochainComplex.single₀ C).map f).f 0)
(I'.ι.f 0)) →
motive { hom := hom, ι_f_zero_comp_hom_f_zero := ι_f_zero_comp_hom_f_zero }) →
motive t |
Lean.Parser.TokenCacheEntry.noConfusionType | Lean.Parser.Types | Sort u → Lean.Parser.TokenCacheEntry → Lean.Parser.TokenCacheEntry → Sort u |
OrderMonoidHom.inlₗ._proof_3 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β],
(Prod.Lex.toLexOrderHom.comp ↑(OrderMonoidHom.inl α β)).toFun 1 =
(Prod.Lex.toLexOrderHom.comp ↑(OrderMonoidHom.inl α β)).toFun 1 |
Representation.IntertwiningMap.lTensor_comp_rTensor | 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 G W}
{τ : Representation A G U} (f : σ.IntertwiningMap ρ) (g : ρ.IntertwiningMap τ),
(Representation.IntertwiningMap.lTensor τ f).comp (Representation.IntertwiningMap.rTensor σ g) = g.tensor f |
Action.instPreservesColimitForgetOfHasColimitComp | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {J : Type u_3}
[inst_2 : CategoryTheory.Category.{v_2, u_3} J] (K : CategoryTheory.Functor J (Action V G))
[CategoryTheory.Limits.HasColimit (K.comp (Action.forget V G))],
CategoryTheory.Limits.PreservesColimit K (Action.forget V G) |
CompleteLat.dualEquiv | Mathlib.Order.Category.CompleteLat | CompleteLat ≌ CompleteLat |
FirstOrder.Language.Term.subst.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} {β : Type v'} (x : α → L.Term β) (l : ℕ) (f : L.Functions l)
(ts : Fin l → L.Term α), (FirstOrder.Language.func f ts).subst x = FirstOrder.Language.func f fun i => (ts i).subst x |
Std.Tactic.BVDecide.BVExpr.decEq._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (lw ln rw rn : ℕ), ln = rn ∧ lw = rw → lw = rw |
Lean.Compiler.LCNF.UnreachableBranches.Value.bot.sizeOf_spec | Lean.Compiler.LCNF.ElimDeadBranches | sizeOf Lean.Compiler.LCNF.UnreachableBranches.Value.bot = 1 |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.finite_projective.match_1_3 | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(S : Finset (M × Module.Dual R M)) (f : (↥S →₀ Module.Dual R M) →ₗ[R] R),
let N := Module.Dual R M;
∀ (motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : R →ₗ[R] ↥S →₀ N) (hg : f ∘ₗ g = LinearMap.id), motive ⋯) → motive x |
_private.Mathlib.Analysis.SpecialFunctions.Log.Deriv.0.Real.le_log_one_add_of_nonneg._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
CategoryTheory.OverPresheafAux.counitForward_naturality₁ | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)}
{F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type v)} (η : F ⟶ G)
(s : (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ) (x : F.obj s),
CategoryTheory.OverPresheafAux.counitForward G (Opposite.unop s) (η.app s x) =
(CategoryTheory.OverPresheafAux.counitForward F (Opposite.unop s) x).map₁
(CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁ η) ⋯ |
Order.coheight_bot_eq_krullDim | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α], ↑(Order.coheight ⊥) = Order.krullDim α |
CategoryTheory.Abelian.isoModSerre_kernel_eq_leftBousfield_W_of_rightAdjoint | Mathlib.CategoryTheory.Abelian.SerreClass.Bousfield | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] {G : CategoryTheory.Functor D C}
[inst_4 : CategoryTheory.Limits.PreservesFiniteLimits G] [inst_5 : CategoryTheory.Limits.PreservesFiniteColimits G]
{F : CategoryTheory.Functor C D} (adj : G ⊣ F) [F.Full] [F.Faithful],
G.kernel.isoModSerre = CategoryTheory.ObjectProperty.isLocal fun x => x ∈ Set.range F.obj |
Frm.hasForgetToLat._proof_2 | Mathlib.Order.Category.Frm | ∀ {X Y Z : Frm} (f : X ⟶ Y) (g : Y ⟶ Z),
Lat.ofHom { toFun := ⇑(Frm.Hom.hom (CategoryTheory.CategoryStruct.comp f g)), map_sup' := ⋯, map_inf' := ⋯ } =
CategoryTheory.CategoryStruct.comp (Lat.ofHom { toFun := ⇑(Frm.Hom.hom f), map_sup' := ⋯, map_inf' := ⋯ })
(Lat.ofHom { toFun := ⇑(Frm.Hom.hom g), map_sup' := ⋯, map_inf' := ⋯ }) |
Multiset.count_bind | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} [inst : DecidableEq α] {m : Multiset β} {f : β → Multiset α} {a : α},
Multiset.count a (m.bind f) = (Multiset.map (fun b => Multiset.count a (f b)) m).sum |
groupCohomology.H1Iso | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep k G) → groupCohomology.H1 A ≅ (groupCohomology.shortComplexH1 A).moduleCatLeftHomologyData.H |
LinearPMap.graph | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} → [inst_3 : AddCommGroup F] → [inst_4 : Module R F] → (E →ₗ.[R] F) → Submodule R (E × F) |
Monoid.PushoutI.homEquiv._proof_8 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} (fst : (i : ι) → G i →* K) (snd : H →* K)
(property : ∀ (i : ι), ((fst, snd).1 i).comp (φ i) = (fst, snd).2),
(fun f => ⟨(fun i => f.comp (Monoid.PushoutI.of i), f.comp (Monoid.PushoutI.base φ)), ⋯⟩)
((fun f => Monoid.PushoutI.lift (↑f).1 (↑f).2 ⋯) ⟨(fst, snd), property⟩) =
⟨(fst, snd), property⟩ |
Equiv.trans_cancel_left | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} (e : α ≃ β) (f : β ≃ γ) (g : α ≃ γ), e.trans f = g ↔ f = e.symm.trans g |
Wbtw.angle₂₃₁_eq_zero_of_ne | Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P}, Wbtw ℝ p₁ p₂ p₃ → p₂ ≠ p₃ → EuclideanGeometry.angle p₂ p₃ p₁ = 0 |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.support_swap_mul_swap._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {a : α}, (a ∈ []) = False |
CochainComplex.HomComplex.Cochain.shift_v' | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a p q : ℤ) (hpq : p + n = q),
(γ.shift a).v p q hpq = γ.v (p + a) (q + a) ⋯ |
Finsupp.LinearEquiv.finsuppUnique._proof_2 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ (M : Type u_2) [inst : AddCommMonoid M] (α : Type u_1) [inst_1 : Unique α] (x x_1 : α →₀ M),
(Finsupp.equivFunOnFinite.trans (Equiv.funUnique α M)).toFun (x + x_1) =
(Finsupp.equivFunOnFinite.trans (Equiv.funUnique α M)).toFun (x + x_1) |
Std.TreeSet.max?_eq_some_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback : α}, t.max? = some (t.maxD fallback) |
HasFDerivAt.of_local_left_inverse | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E ≃L[𝕜] F} {g : F → E} {a : F},
ContinuousAt g a → HasFDerivAt f (↑f') (g a) → (∀ᶠ (y : F) in nhds a, f (g y) = y) → HasFDerivAt g (↑f'.symm) a |
List.Nodup.getEquiv._proof_1 | Mathlib.Data.List.NodupEquivFin | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α),
l.Nodup → ∀ (i : Fin l.length), (fun x => ⟨List.idxOf (↑x) l, ⋯⟩) ((fun i => ⟨l.get i, ⋯⟩) i) = i |
Valuation.FiniteField.algebraMap_eq_one | Mathlib.RingTheory.Valuation.FiniteField | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommMonoidWithZero Γ₀] {A : Type u_2} [inst_1 : Ring A] (v : Valuation A Γ₀)
{Fq : Type u_3} [inst_2 : Field Fq] [Finite Fq] [inst_4 : Algebra Fq A] (a : Fq), a ≠ 0 → v ((algebraMap Fq A) a) = 1 |
LinearMap.mem_ker._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [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₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) |
Complex.tan_periodic | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | Function.Periodic Complex.tan ↑Real.pi |
Mathlib.Tactic.LibraryRewrite.Rewrite.recOn | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Mathlib.Tactic.LibraryRewrite.Rewrite → Sort u} →
(t : Mathlib.Tactic.LibraryRewrite.Rewrite) →
((symm : Bool) →
(proof replacement : Lean.Expr) →
(stringLength : ℕ) →
(extraGoals : Array (Lean.MVarId × Lean.BinderInfo)) →
(makesNewMVars : Bool) →
motive
{ symm := symm, proof := proof, replacement := replacement, stringLength := stringLength,
extraGoals := extraGoals, makesNewMVars := makesNewMVars }) →
motive t |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.hittingAfter_bot_le_iff._simp_1_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n i : ι} {ω : Ω} [WellFoundedLT ι], (MeasureTheory.hittingAfter u s n ω ≤ ↑i) = ∃ j ∈ Set.Icc n i, u j ω ∈ s |
IO.userError | Init.System.IOError | String → IO.Error |
HeytingAlgebra.toOrderBot | Mathlib.Order.Heyting.Basic | {α : Type u_4} → [self : HeytingAlgebra α] → OrderBot α |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.SuccessPoint.mk.injEq | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | ∀ (lvl : Lean.Level) (cursorPred letMutsPred : Lean.Expr) (lvl_1 : Lean.Level) (cursorPred_1 letMutsPred_1 : Lean.Expr),
({ lvl := lvl, cursorPred := cursorPred, letMutsPred := letMutsPred } =
{ lvl := lvl_1, cursorPred := cursorPred_1, letMutsPred := letMutsPred_1 }) =
(lvl = lvl_1 ∧ cursorPred = cursorPred_1 ∧ letMutsPred = letMutsPred_1) |
CategoryTheory.MonoOver.map.congr_simp | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Mono f], CategoryTheory.MonoOver.map f = CategoryTheory.MonoOver.map f_1 |
Pell.pos_generator_iff_fundamental | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d),
(1 < a.x ∧ 0 < a.y ∧ ∀ (b : Pell.Solution₁ d), ∃ n, b = a ^ n ∨ b = -a ^ n) ↔ Pell.IsFundamental a |
AddGrpCat.uliftFunctor_map | Mathlib.Algebra.Category.Grp.Basic | ∀ {x x_1 : AddGrpCat} (f : x ⟶ x_1),
AddGrpCat.uliftFunctor.map f =
AddGrpCat.ofHom (AddEquiv.ulift.symm.toAddMonoidHom.comp ((AddGrpCat.Hom.hom f).comp AddEquiv.ulift.toAddMonoidHom)) |
powersHom_apply | Mathlib.Algebra.Group.Nat.Hom | ∀ {M : Type u_1} [inst : Monoid M] (x : M) (n : Multiplicative ℕ), ((powersHom M) x) n = x ^ Multiplicative.toAdd n |
LocallyConstant.instNonAssocRing._proof_10 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocRing Y] (x : ℤ), ⇑↑x = ⇑↑x |
Std.Roi.Sliceable.noConfusionType | Init.Data.Slice.Notation | Sort u_1 →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
Std.Roi.Sliceable α β γ → {α' : Type u} → {β' : Type v} → {γ' : Type w} → Std.Roi.Sliceable α' β' γ' → Sort u_1 |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.CompleteLattice.isCompactElement_iff_exists_le_sSup_of_le_sSup._simp_1_7 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u} (s : Set α), (∅ ⊆ s) = True |
_private.Lean.Parser.Types.0.Lean.Parser.ParserContext.mk.injEq | Lean.Parser.Types | ∀ (toParserContextCore toParserContextCore_1 : Lean.Parser.ParserContextCore),
({ toParserContextCore := toParserContextCore } = { toParserContextCore := toParserContextCore_1 }) =
(toParserContextCore = toParserContextCore_1) |
Lean.Lsp.DocumentSymbolAux.recOn | Lean.Data.Lsp.LanguageFeatures | {Self : Type} →
{motive : Lean.Lsp.DocumentSymbolAux Self → Sort u} →
(t : Lean.Lsp.DocumentSymbolAux Self) →
((name : String) →
(detail? : Option String) →
(kind : Lean.Lsp.SymbolKind) →
(range selectionRange : Lean.Lsp.Range) →
(children? : Option (Array Self)) →
motive
{ name := name, detail? := detail?, kind := kind, range := range, selectionRange := selectionRange,
children? := children? }) →
motive t |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.ker_coprod_of_disjoint_range._simp_1_3 | Mathlib.LinearAlgebra.Prod | ∀ {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₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x |
MulEquiv.symm_toContinuousMulEquiv | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {G : Type u} [inst : TopologicalSpace G] {H : Type v} [inst_1 : TopologicalSpace H] [inst_2 : Mul G] [inst_3 : Mul H]
{e : G ≃* H} (he : ∀ (s : Set H), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s),
(e.toContinuousMulEquiv he).symm = e.symm.toContinuousMulEquiv ⋯ |
MeasureTheory.IsFundamentalDomain.mk'' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α},
MeasureTheory.NullMeasurableSet s μ →
(∀ᵐ (x : α) ∂μ, ∃ g, g • x ∈ s) →
(∀ (g : G), g ≠ 1 → MeasureTheory.AEDisjoint μ (g • s) s) →
(∀ (g : G), MeasureTheory.Measure.QuasiMeasurePreserving (fun x => g • x) μ μ) →
MeasureTheory.IsFundamentalDomain G s μ |
Lean.Elab.Term.LValResolution.noConfusionType | Lean.Elab.App | Sort u → Lean.Elab.Term.LValResolution → Lean.Elab.Term.LValResolution → Sort u |
IsPrecomplete.prec | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsPrecomplete I M →
∀ {f : ℕ → M}, (∀ {m n : ℕ}, m ≤ n → f m ≡ f n [SMOD I ^ m • ⊤]) → ∃ L, ∀ (n : ℕ), f n ≡ L [SMOD I ^ n • ⊤] |
AddMonoidAlgebra.tensorEquiv.invFun.eq_1 | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | ∀ {R : Type u_1} {M : Type u_2} {A : Type u_4} {B : Type u_5} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : CommSemiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddCommMonoid M],
AddMonoidAlgebra.tensorEquiv.invFun =
AddMonoidAlgebra.liftNCAlgHom (Algebra.TensorProduct.map (AlgHom.id A A) AddMonoidAlgebra.singleZeroAlgHom)
((↑Algebra.TensorProduct.includeRight.toRingHom).comp (AddMonoidAlgebra.of B M)) ⋯ |
Cardinal.prod_eq_two_power | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {ι : Type u} [Infinite ι] {c : ι → Cardinal.{v}},
(∀ (i : ι), 2 ≤ c i) →
(∀ (i : ι), Cardinal.lift.{u, v} (c i) ≤ Cardinal.lift.{v, u} (Cardinal.mk ι)) →
Cardinal.prod c = 2 ^ Cardinal.lift.{v, u} (Cardinal.mk ι) |
Lean.Meta.Grind.CongrTheoremCacheKey.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{f : Lean.Expr} →
{numArgs : ℕ} →
{f' : Lean.Expr} →
{numArgs' : ℕ} →
{ f := f, numArgs := numArgs } = { f := f', numArgs := numArgs' } → (f = f' → numArgs = numArgs' → P) → P |
Lean.Meta.Grind.EMatchTheoremConstraint.depthLt.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs n : ℕ), sizeOf (Lean.Meta.Grind.EMatchTheoremConstraint.depthLt lhs n) = 1 + sizeOf lhs + sizeOf n |
Polynomial.int | Mathlib.Algebra.Ring.Subring.IntPolynomial | {K : Type u_1} → [inst : Field K] → (R : Subring K) → (P : Polynomial K) → (∀ (n : ℕ), P.coeff n ∈ R) → Polynomial ↥R |
ContinuousLinearMap.instLoewnerPartialOrder | Mathlib.Analysis.InnerProductSpace.Positive | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] → [inst_1 : NormedAddCommGroup E] → [inst_2 : InnerProductSpace 𝕜 E] → PartialOrder (E →L[𝕜] E) |
CochainComplex.triangleOfDegreewiseSplitRotateRotateIso | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
(CochainComplex.triangleOfDegreewiseSplit S σ).rotate.rotate ≅
CochainComplex.mappingCone.triangle (CochainComplex.homOfDegreewiseSplit S σ) |
SubtractionCommMonoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {G : Type u} →
(add : G → G → G) →
(∀ (a b c : G), a + b + c = a + (b + c)) →
(zero : G) →
(∀ (a : G), 0 + a = a) →
(∀ (a : G), a + 0 = a) →
(nsmul : ℕ → G → G) →
autoParam (∀ (x : G), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : G), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(neg : G → G) →
(sub : G → G → G) →
autoParam (∀ (a b : G), a - b = a + neg b) SubNegMonoid.sub_eq_add_neg._autoParam →
(zsmul : ℤ → G → G) →
autoParam (∀ (a : G), zsmul 0 a = 0) SubNegMonoid.zsmul_zero'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zsmul (↑n.succ) a = zsmul (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam →
autoParam (∀ (n : ℕ) (a : G), zsmul (Int.negSucc n) a = neg (zsmul (↑n.succ) a))
SubNegMonoid.zsmul_neg'._autoParam →
(∀ (x : G), neg (neg x) = x) →
(∀ (a b : G), neg (a + b) = neg b + neg a) →
(∀ (a b : G), a + b = 0 → neg a = b) →
(∀ (a b : G), a + b = b + a) → SubtractionCommMonoid G |
_private.Init.Data.ToString.Basic.0.List.toString.match_1 | Init.Data.ToString.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((x : α) → motive [x]) → ((x : α) → (xs : List α) → motive (x :: xs)) → motive x |
Nat.succ_lt_of_lt_pred | Init.Data.Nat.Basic | ∀ {n : ℕ} {m : ℕ}, n < m.pred → n.succ < m |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.LiveVars.borrows._default | Lean.Compiler.LCNF.ExplicitRC | Std.HashSet Lean.FVarId |
CategoryTheory.Limits.Cones.eta._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F)
(j : J),
c.π.app j = CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl c.pt).hom ({ pt := c.pt, π := c.π }.π.app j) |
CategoryTheory.MonoidalCategory.id_whiskerLeft_symm_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X X' : C}
(f : X ⟶ X') {Z : C} (h : X' ⟶ Z),
CategoryTheory.CategoryStruct.comp f h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) f)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X').hom h)) |
_private.Mathlib.Computability.TMConfig.0.Turing.ToPartrec.Code.eval.match_1.eq_4 | Mathlib.Computability.TMConfig | ∀ (motive : Turing.ToPartrec.Code → Sort u_1) (f fs : Turing.ToPartrec.Code)
(h_1 : Unit → motive Turing.ToPartrec.Code.zero') (h_2 : Unit → motive Turing.ToPartrec.Code.succ)
(h_3 : Unit → motive Turing.ToPartrec.Code.tail) (h_4 : (f fs : Turing.ToPartrec.Code) → motive (f.cons fs))
(h_5 : (f g : Turing.ToPartrec.Code) → motive (f.comp g)) (h_6 : (f g : Turing.ToPartrec.Code) → motive (f.case g))
(h_7 : (f : Turing.ToPartrec.Code) → motive f.fix),
(match f.cons fs with
| Turing.ToPartrec.Code.zero' => h_1 ()
| Turing.ToPartrec.Code.succ => h_2 ()
| Turing.ToPartrec.Code.tail => h_3 ()
| f.cons fs => h_4 f fs
| f.comp g => h_5 f g
| f.case g => h_6 f g
| f.fix => h_7 f) =
h_4 f fs |
_private.Std.Data.Internal.List.Associative.0.List.getLast?.match_1.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as |
HMod.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HMod α β γ |
EuclideanDomain.mul_div_assoc | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] (x : R) {y z : R}, z ∣ y → x * y / z = x * (y / z) |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.computePrioritizedCompletionPartitions.match_13 | Lean.Server.Completion.CompletionInfoSelection | (motive : (Bool × Option String.Pos.Raw) × Array (Lean.Server.Completion.ContextualizedCompletionInfo × ℕ) → Sort u_1) →
(x : (Bool × Option String.Pos.Raw) × Array (Lean.Server.Completion.ContextualizedCompletionInfo × ℕ)) →
((isId₂ : Bool) →
(size₂? : Option String.Pos.Raw) →
(snd : Array (Lean.Server.Completion.ContextualizedCompletionInfo × ℕ)) → motive ((isId₂, size₂?), snd)) →
motive x |
AlternatingMap.smulRight._proof_1 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_2} {M₁ : Type u_4} {M₂ : Type u_1} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] (f : M₁ [⋀^ι]→ₗ[R] R) (z : M₂) (v : ι → M₁)
(i j : ι), v i = v j → i ≠ j → ((↑f).smulRight z).toFun v = 0 |
_private.Lean.Compiler.LCNF.SimpCase.0.Lean.Compiler.LCNF.simplifyCases._proof_2 | Lean.Compiler.LCNF.SimpCase | ∀ (alts : Array (Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure)), alts.size = 1 → 0 < alts.size |
Lean.Server.CodeActionResolveData.mk | Lean.Server.CodeActions.Basic | Lean.Lsp.CodeActionParams → Lean.Name → ℕ → Lean.Server.CodeActionResolveData |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.applyPartition.go.match_1.splitter | Std.Data.DTreeMap.Internal.Model | (motive : Ordering → Sort u_1) →
(x : Ordering) →
(x = Ordering.lt → motive Ordering.lt) →
(x = Ordering.eq → motive Ordering.eq) → (x = Ordering.gt → motive Ordering.gt) → motive x |
Lean.Parser.ParserAttributeHook.casesOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
(t : Lean.Parser.ParserAttributeHook) →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) → motive t |
CategoryTheory.Adjunction.Triple.whiskerRight_rightToLeft | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H) [inst_2 : G.Full] [inst_3 : G.Faithful],
CategoryTheory.Functor.whiskerRight t.rightToLeft G = CategoryTheory.CategoryStruct.comp t.adj₂.counit t.adj₁.unit |
NormedAddCommGroup.ofAddDist' | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} →
[inst : Norm E] →
[inst_1 : AddCommGroup E] →
[inst_2 : MetricSpace E] →
(∀ (x : E), ‖x‖ = dist 0 x) → (∀ (x y z : E), dist (z + x) (z + y) ≤ dist x y) → NormedAddCommGroup E |
AddAut.instAddGroup._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) [inst : Add M] (x : AddAut M), nsmulRecAuto 0 x = 0 |
PiLp.continuousLinearEquiv._proof_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_1} (β : ι → Type u_2) [inst : (i : ι) → SeminormedAddCommGroup (β i)],
Continuous WithLp.ofLp |
_private.Mathlib.RingTheory.Polynomial.Content.0.Polynomial.content_eq_gcd_range_of_lt._simp_1_1 | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, (n ∈ p.support) = (p.coeff n ≠ 0) |
_private.Batteries.Tactic.PrintDependents.0.Batteries.Tactic.CollectDependents.collect.match_1 | Batteries.Tactic.PrintDependents | (motive : Option Bool → Sort u_1) →
(x : Option Bool) → ((b : Bool) → motive (some b)) → ((x : Option Bool) → motive x) → motive x |
CategoryTheory.Equivalence.instMonoidalInverseTrans | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{E : Type u₃} →
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] →
[inst_5 : CategoryTheory.MonoidalCategory E] →
(e : C ≌ D) →
[e.inverse.Monoidal] → (e' : D ≌ E) → [e'.inverse.Monoidal] → (e.trans e').inverse.Monoidal |
MvPowerSeries.rescaleUnit | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (r : R) (f : PowerSeries R),
(PowerSeries.rescale r) f = (MvPowerSeries.rescale fun x => r) f |
dist_le_of_le_geometric_two_of_tendsto₀ | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {C : ℝ} {f : ℕ → α},
(∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C / 2 / 2 ^ n) →
∀ {a : α}, Filter.Tendsto f Filter.atTop (nhds a) → dist (f 0) a ≤ C |
Ideal.quotientKerAlgEquivOfSurjective._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R₁ : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A]
[inst_3 : Semiring B] [inst_4 : Algebra R₁ B] {f : A →ₐ[R₁] B} (hf : Function.Surjective ⇑f),
Function.RightInverse (Classical.choose ⋯) ⇑f |
Real.Angle.sin_coe | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (x : ℝ), (↑x).sin = Real.sin x |
CategoryTheory.tensorRightHomEquiv._proof_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y Y' Z : C) [inst_2 : CategoryTheory.ExactPairing Y Y']
(f : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
(fun f =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator Z Y' Y).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (ε_ Y Y'))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor Z).hom)))
((fun f =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (η_ Y Y'))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Y').inv
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y'))))
f) =
f |
Differentiable.fun_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a b : E → 𝔸},
Differentiable 𝕜 a → Differentiable 𝕜 b → Differentiable 𝕜 fun i => a i * b i |
TypeVec.dropFun_from_append1_drop_last | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} (n + 1)}, TypeVec.dropFun TypeVec.fromAppend1DropLast = TypeVec.id |
Lean.Elab.Term.getMatchAlt | Lean.Elab.Match | (k : Lean.SyntaxNodeKinds) → Lean.Syntax → Option (Lean.Elab.Term.MatchAltView k) |
SMulWithZero.casesOn | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
[inst : Zero M₀] →
[inst_1 : Zero A] →
{motive : SMulWithZero M₀ A → Sort u} →
(t : SMulWithZero M₀ A) →
([toSMulZeroClass : SMulZeroClass M₀ A] →
(zero_smul : ∀ (m : A), 0 • m = 0) →
motive { toSMulZeroClass := toSMulZeroClass, zero_smul := zero_smul }) →
motive t |
Std.TreeSet.Raw.min?_eq_some_iff_mem_and_forall | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [Std.LawfulEqCmp cmp],
t.WF → ∀ {km : α}, t.min? = some km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true |
Summable.abs | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : UniformSpace α] [IsUniformAddGroup α] [CompleteSpace α] {f : ι → α}, Summable f → Summable fun x => |f x| |
Lean.Meta.Grind.EvalTactic | Lean.Meta.Tactic.Grind.Types | Type |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_emod.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : ℤ → Prop) (a : ℤ), (∀ (a : ℕ), motive (Int.ofNat a)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive a |
CategoryTheory.PreGaloisCategory.GaloisCategory.getFiberFunctor | Mathlib.CategoryTheory.Galois.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{u₂, u₁} C] → [CategoryTheory.GaloisCategory C] → CategoryTheory.Functor C FintypeCat |
Set.prod_insert | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β}, s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t |
Perfect | Mathlib.Topology.Perfect | {α : Type u_1} → [TopologicalSpace α] → Set α → Prop |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_cons_cons._simp_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a * a ^ n = a ^ (n + 1) |
groupHomology.chainsMap_f_single | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep k G} {B : Rep k H} (f : G →* H)
(φ : A ⟶ (Action.res (ModuleCat k) f).obj B) (n : ℕ) (x : Fin n → G) (a : ↑A.V),
((CategoryTheory.ConcreteCategory.hom ((groupHomology.chainsMap f φ).f n)) fun₀ | x => a) =
fun₀ | ⇑f ∘ x => (CategoryTheory.ConcreteCategory.hom φ.hom) a |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic___macroRules__private_Mathlib_MeasureTheory_Function_StronglyMeasurable_Basic_0_MeasureTheory_term_→ₛ__1» | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | Lean.Macro |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.