name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.DTreeMap.Internal.Impl.toList_filter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {f : (a : α) → β a → Bool},
t.WF → (Std.DTreeMap.Internal.Impl.filter! f t).toList = List.filter (fun p => f p.fst p.snd) t.toList |
Equiv.sumArrowEquivProdArrow._proof_1 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_3) (β : Type u_1) (γ : Type u_2) (f : α ⊕ β → γ),
(fun p => Sum.elim p.1 p.2) ((fun f => (f ∘ Sum.inl, f ∘ Sum.inr)) f) = f |
Module.Baer.ExtensionOfMaxAdjoin.ideal._proof_1 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_1} [inst : Ring R] {N : Type u_2} [inst_1 : AddCommGroup N] [inst_2 : Module R N], IsScalarTower R R N |
Aesop.RuleApplication.successProbability? | Aesop.RuleTac.Basic | Aesop.RuleApplication → Option Aesop.Percent |
Nat.range_succ_eq_Iic | Mathlib.Order.Interval.Finset.Nat | ∀ (n : ℕ), Finset.range (n + 1) = Finset.Iic n |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.AddSubmonoid.map_id.match_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M) (x : M)
(motive : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S → Prop) (x_1 : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S),
(∀ (h : x ∈ ↑S), motive ⋯) → motive x_1 |
Lean.Elab.Structural.IndGroupInst.toMessageData | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → Lean.MessageData |
List.all_one_of_le_one_le_of_prod_eq_one | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : CommMonoid M] [inst_1 : PartialOrder M] [IsOrderedMonoid M] {l : List M},
(∀ x ∈ l, 1 ≤ x) → l.prod = 1 → ∀ {x : M}, x ∈ l → x = 1 |
ClopenUpperSet.noConfusion | Mathlib.Topology.Sets.Order | {P : Sort u} →
{α : Type u_2} →
{inst : TopologicalSpace α} →
{inst_1 : LE α} →
{t : ClopenUpperSet α} →
{α' : Type u_2} →
{inst' : TopologicalSpace α'} →
{inst'_1 : LE α'} →
{t' : ClopenUpperSet α'} →
α = α' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → ClopenUpperSet.noConfusionType P t t' |
Urysohns.CU.approx.match_1 | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} →
[inst : TopologicalSpace X] →
{P : Set X → Set X → Prop} →
(motive : ℕ → Urysohns.CU P → X → Sort u_2) →
(x : ℕ) →
(x_1 : Urysohns.CU P) →
(x_2 : X) →
((c : Urysohns.CU P) → (x : X) → motive 0 c x) →
((n : ℕ) → (c : Urysohns.CU P) → (x : X) → motive n.succ c x) → motive x x_1 x_2 |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_1} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_2))
(p : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))) {j j' : CategoryTheory.SingleObj M},
↑p ∈ MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)) |
Lean.Elab.Tactic.Do.ProofMode.elabMExact | Lean.Elab.Tactic.Do.ProofMode.Exact | Lean.Elab.Tactic.Tactic |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.absolutelyContinuous_of_compProd._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ Set.univ = 0) = (μ = 0) |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.coe_range_dense._simp_1_2 | Mathlib.RingTheory.LaurentSeries | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
Rep.diagonalOneIsoLeftRegular_inv_hom | Mathlib.RepresentationTheory.Rep | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Monoid G],
(Rep.diagonalOneIsoLeftRegular k G).inv.hom = ModuleCat.ofHom ↑(Finsupp.domLCongr (Equiv.funUnique (Fin 1) G).symm) |
Lean.Compiler.LCNF.instantiateRangeArgs | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Expr → ℕ → ℕ → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Expr |
SpectrumRestricts.starAlgHom_injective | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Semifield S] [inst_6 : StarRing S]
[inst_7 : MetricSpace S] [inst_8 : IsTopologicalSemiring S] [inst_9 : ContinuousStar S] [inst_10 : Ring A]
[inst_11 : StarRing A] [inst_12 : Algebra S A] [inst_13 : Algebra R S] [inst_14 : Algebra R A]
[inst_15 : IsScalarTower R S A] [inst_16 : StarModule R S] [inst_17 : ContinuousSMul R S] {a : A}
{φ : C(↑(spectrum S a), S) →⋆ₐ[S] A},
Function.Injective ⇑φ →
∀ {f : C(S, R)} (h : SpectrumRestricts a ⇑f),
Function.Injective ⇑(algebraMap R S) → Function.Injective ⇑(SpectrumRestricts.starAlgHom φ h) |
AddCircle.homeomorphAddCircle_symm_apply_mk | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p q : 𝕜) [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [inst_4 : OrderTopology 𝕜] (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜),
(AddCircle.homeomorphAddCircle p q hp hq).symm ↑x = ↑(x * (q⁻¹ * p)) |
ZeroAtInftyContinuousMap.coe_zero | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β], ⇑0 = 0 |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.rel | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
Equivalence (Lean.Grind.IntModule.OfNatModule.r α) →
Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α → Prop |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.projective_of_finitePresentation.match_1_1 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂) → Prop) (x : ∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂),
(∀ (w : ℕ) (f : M →ₗ[R] Fin w →₀ R) (g : (Fin w →₀ R) →ₗ[R] M) (eq : LinearMap.id = g ∘ₗ f), motive ⋯) → motive x |
Module.finitePresentation_iff_finite | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsNoetherianRing R],
Module.FinitePresentation R M ↔ Module.Finite R M |
AddMonoidAlgebra.ofMagma_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ (R : Type u_8) (M : Type u_9) [inst : Semiring R] [inst_1 : Add M] (a : Multiplicative M),
(AddMonoidAlgebra.ofMagma R M) a = AddMonoidAlgebra.single (Multiplicative.toAdd a) 1 |
FilterBasis | Mathlib.Order.Filter.Bases.Basic | Type u_6 → Type u_6 |
List.le_max_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α] {l : List α} {a : α}
(ha : a ∈ l), a ≤ l.max ⋯ |
bind_pure_unit | Init.Control.Lawful.Basic | ∀ {m : Type u_1 → Type u_2} [inst : Monad m] [LawfulMonad m] {x : m PUnit.{u_1 + 1}},
(do
x
pure PUnit.unit) =
x |
rank_eq_card_basis | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type w} [inst_4 : Fintype ι] (h : Module.Basis ι R M), Module.rank R M = ↑(Fintype.card ι) |
MultilinearMap.currySum._proof_7 | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type u_5} {ι : Type u_2} {ι' : Type u_1} {M₂ : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_4} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)] (f : MultilinearMap R N M₂) [inst_5 : DecidableEq ι]
(u : (i : ι) → N (Sum.inl i)) (i : ι) (x : N (Sum.inl i)) [inst_6 : DecidableEq ι'] (m : (i : ι') → N (Sum.inr i))
(i_1 : ι') (x_1 y : N (Sum.inr i_1)),
(f fun t => Sum.rec (Function.update u i x) (Function.update m i_1 (x_1 + y)) t) =
(f fun t => Sum.rec (Function.update u i x) (Function.update m i_1 x_1) t) +
f fun t => Sum.rec (Function.update u i x) (Function.update m i_1 y) t |
MeasureTheory.measurePreserving_pi_empty | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u} {α : ι → Type v} [inst : Fintype ι] [inst_1 : IsEmpty ι] {m : (i : ι) → MeasurableSpace (α i)}
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit))
(MeasureTheory.Measure.pi μ) (MeasureTheory.Measure.dirac ()) |
definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [FiniteDimensional 𝕜 E] {n : ℕ},
Module.finrank 𝕜 E = n →
∀ [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
DirectSum.IsInternal V →
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
Fintype.card ((i : ι) × Fin (Module.finrank 𝕜 ↥(V i))) = n |
BoundedContinuousFunction.rec | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
{motive : BoundedContinuousFunction α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(map_bounded' : ∃ C, ∀ (x y : α), dist (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C) →
motive { toContinuousMap := toContinuousMap, map_bounded' := map_bounded' }) →
(t : BoundedContinuousFunction α β) → motive t |
CategoryTheory.ShortComplex.opcyclesFunctor | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasKernels C] →
[CategoryTheory.Limits.HasCokernels C] → CategoryTheory.Functor (CategoryTheory.ShortComplex C) C |
monovaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
MonovaryOn (-f) (-g) s ↔ MonovaryOn f g s |
Lean.Elab.Term.elabLetDelayedDecl | Lean.Elab.Binders | Lean.Elab.Term.TermElab |
Array.appendCore.loop | Init.Prelude | {α : Type u} → Array α → ℕ → ℕ → Array α → Array α |
Subgroup.FG.eq_1 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG = ∃ S, Subgroup.closure ↑S = P |
instDecidableEqColex | Mathlib.Order.Synonym | (α : Type u_2) → [h : DecidableEq α] → DecidableEq (Colex α) |
AlgEquiv.aut._proof_8 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(x : A₁ ≃ₐ[R] A₁), 1 * x = x |
Lean.Server.Test.Runner.rpcRequest | Lean.Server.Test.Runner | {α : Type u_1} → Lean.Name → [Lean.ToJson α] → α → (β : Type) → [Lean.FromJson β] → Lean.Server.Test.Runner.RunnerM β |
MulEquiv.toMonCatIso | Mathlib.Algebra.Category.MonCat.Basic | {X Y : Type u} → [inst : Monoid X] → [inst_1 : Monoid Y] → X ≃* Y → (MonCat.of X ≅ MonCat.of Y) |
InfClosed.infClosure_eq | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeInf α] {s : Set α}, InfClosed s → infClosure s = s |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A₁] [inst_4 : CategoryTheory.Category.{v₅, u₅} B₁]
[inst_5 : CategoryTheory.Category.{v₆, u₆} C₁] {F₁ : CategoryTheory.Functor A₁ B₁} {G₁ : CategoryTheory.Functor C₁ B₁}
{X : Type u₇} {Y : Type u₈} {Z : Type u₉} [inst_6 : CategoryTheory.Category.{v₇, u₇} X]
[inst_7 : CategoryTheory.Category.{v₈, u₈} Y] [inst_8 : CategoryTheory.Category.{v₉, u₉} Z]
(ψ : CategoryTheory.Limits.CatCospanTransform F G F₁ G₁) (U : CategoryTheory.Functor X Y)
(V : CategoryTheory.Functor Y Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CatCommSq.iso
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj (U.comp V))
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Z).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj (U.comp V))).hom
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Z).obj ψ).whiskerLeft
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp F₁ G₁ U V).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight
(CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjComp F G U V).hom
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj ψ))
(CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj V).associator
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj U)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj ψ)).hom
(CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj V).whiskerLeft
(CategoryTheory.CatCommSq.iso
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj U)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Y).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform X).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj U)).hom)
(CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj V).associator
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Y).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj U)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight
(CategoryTheory.CatCommSq.iso
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F G).obj V)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Z).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Y).obj ψ)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj V)).hom
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj U))
(((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transform Z).obj ψ).associator
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj V)
((CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose F₁ G₁).obj U)).hom)))) |
AlgebraicGeometry.IsLocallyArtinian.discreteTopology_of_isAffine | Mathlib.AlgebraicGeometry.Artinian | ∀ {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsLocallyArtinian X], DiscreteTopology ↥X |
Lean.Meta.Tactic.Cbv.getMatchTheorems | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Name → Lean.MetaM Lean.Meta.Sym.Simp.Theorems |
CategoryTheory.Bicategory.Adj.iso₂Mk._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
(el : α.l ≅ β.l) (er : β.r ≅ α.r),
(CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) el.hom = er.hom →
(CategoryTheory.Bicategory.conjugateEquiv α.adj β.adj) el.inv = er.inv |
String.Slice.Pos.byte.eq_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos) (h : pos ≠ s.endPos), pos.byte h = s.getUTF8Byte pos.offset ⋯ |
Mathlib.Linter.linter.style.setOption | Mathlib.Tactic.Linter.Style | Lean.Option Bool |
CategoryTheory.Monoidal.InducingFunctorData.rec | Mathlib.CategoryTheory.Monoidal.Transport | {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.MonoidalCategoryStruct D] →
{F : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Monoidal.InducingFunctorData F → Sort u} →
((μIso :
(X Y : D) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj X) (F.obj Y) ≅
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) →
(whiskerLeft_eq :
∀ (X : D) {Y₁ Y₂ : D} (f : Y₁ ⟶ Y₂),
F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f) =
CategoryTheory.CategoryStruct.comp (μIso X Y₁).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (F.map f))
(μIso X Y₂).hom)) →
(whiskerRight_eq :
∀ {X₁ X₂ : D} (f : X₁ ⟶ X₂) (Y : D),
F.map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y) =
CategoryTheory.CategoryStruct.comp (μIso X₁ Y).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (F.map f) (F.obj Y))
(μIso X₂ Y).hom)) →
(tensorHom_eq :
∀ {X₁ Y₁ X₂ Y₂ : D} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
F.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
CategoryTheory.CategoryStruct.comp (μIso X₁ X₂).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (F.map f) (F.map g))
(μIso Y₁ Y₂).hom)) →
(εIso :
CategoryTheory.MonoidalCategoryStruct.tensorUnit C ≅
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit D)) →
(associator_eq :
∀ (X Y Z : D),
F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom =
(((μIso (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso (μIso X Y).symm
(CategoryTheory.Iso.refl (F.obj Z))) ≪≫
CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y)
(F.obj Z) ≪≫
CategoryTheory.MonoidalCategory.tensorIso (CategoryTheory.Iso.refl (F.obj X))
(μIso Y Z) ≪≫
μIso X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom) →
(leftUnitor_eq :
∀ (X : D),
F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom =
(((μIso (CategoryTheory.MonoidalCategoryStruct.tensorUnit D) X).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso εIso.symm
(CategoryTheory.Iso.refl (F.obj X))) ≪≫
CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj X)).hom) →
(rightUnitor_eq :
∀ (X : D),
F.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom =
(((μIso X (CategoryTheory.MonoidalCategoryStruct.tensorUnit D)).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso
(CategoryTheory.Iso.refl (F.obj X)) εIso.symm) ≪≫
CategoryTheory.MonoidalCategoryStruct.rightUnitor (F.obj X)).hom) →
motive
{ μIso := μIso, whiskerLeft_eq := whiskerLeft_eq,
whiskerRight_eq := whiskerRight_eq, tensorHom_eq := tensorHom_eq, εIso := εIso,
associator_eq := associator_eq, leftUnitor_eq := leftUnitor_eq,
rightUnitor_eq := rightUnitor_eq }) →
(t : CategoryTheory.Monoidal.InducingFunctorData F) → motive t |
CategoryTheory.ULift.upFunctor | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (ULift.{u₂, u₁} C) |
List.chain'_map | Mathlib.Data.List.Chain | ∀ {α : Type u} {β : Type v} {R : α → α → Prop} (f : β → α) {l : List β},
List.IsChain R (List.map f l) ↔ List.IsChain (fun a b => R (f a) (f b)) l |
Mathlib.Tactic.filterUpwards | Mathlib.Order.Filter.Defs | Lean.ParserDescr |
instTotallyDisconnectedSpaceMultiplicative | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α], TotallyDisconnectedSpace (Multiplicative α) |
BooleanAlgebra.toBooleanRing._proof_5 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (n : ℕ), (↑n).castDef = ↑n |
Module.Finite.addMonoidHom | Mathlib.LinearAlgebra.FreeModule.Finite.Matrix | ∀ (M : Type v) (N : Type w) [inst : AddCommGroup M] [Module.Finite ℤ M] [Module.Free ℤ M] [inst_3 : AddCommGroup N]
[Module.Finite ℤ N], Module.Finite ℤ (M →+ N) |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c_1) =
(c = c_1) |
Lean.Core.Context.cancelTk? | Lean.CoreM | Lean.Core.Context → Option IO.CancelToken |
_private.Batteries.Data.List.Lemmas.0.List.dropPrefix?.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (list : List α) (h_1 : (list : List α) → motive list [])
(h_2 : (head : α) → (tail : List α) → motive [] (head :: tail))
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match list, [] with
| list, [] => h_1 list
| [], head :: tail => h_2 head tail
| a :: as, b :: bs => h_3 a as b bs) =
h_1 list |
SimpleGraph.Subgraph.Connected.mono' | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph},
(∀ (v w : V), H.Adj v w → H'.Adj v w) → H.verts = H'.verts → H.Connected → H'.Connected |
dvd_mul_gcd_of_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ m * n → k ∣ m * gcd k n |
CategoryTheory.GlueData.mk | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
(J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
autoParam (∀ (i j : J), CategoryTheory.Mono (f i j)) CategoryTheory.GlueData.f_mono._autoParam →
(f_hasPullback :
autoParam (∀ (i j k : J), CategoryTheory.Limits.HasPullback (f i j) (f i k))
CategoryTheory.GlueData.f_hasPullback._autoParam) →
autoParam (∀ (i : J), CategoryTheory.IsIso (f i i)) CategoryTheory.GlueData.f_id._autoParam →
(t : (i j : J) → V (i, j) ⟶ V (j, i)) →
(∀ (i : J), t i i = CategoryTheory.CategoryStruct.id (V (i, i))) →
(t' :
(i j k : J) →
CategoryTheory.Limits.pullback (f i j) (f i k) ⟶
CategoryTheory.Limits.pullback (f j k) (f j i)) →
(∀ (i j k : J),
CategoryTheory.CategoryStruct.comp (t' i j k)
(CategoryTheory.Limits.pullback.snd (f j k) (f j i)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (f i j) (f i k))
(t i j)) →
(∀ (i j k : J),
CategoryTheory.CategoryStruct.comp (t' i j k)
(CategoryTheory.CategoryStruct.comp (t' j k i) (t' k i j)) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.pullback (f i j) (f i k))) →
CategoryTheory.GlueData C |
Std.Rio.mem_iff_mem_Rco | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Rio α} [inst : LE α] [inst_1 : LT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α] [Std.Rxo.IsAlwaysFinite α] {a : α},
a ∈ r ↔ a ∈ Std.PRange.UpwardEnumerable.least...r.upper |
Filter.div_le_div_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f₁ f₂ g : Filter α}, f₁ ≤ f₂ → f₁ / g ≤ f₂ / g |
_private.Mathlib.Analysis.PSeries.0.Real.summable_nat_rpow_inv._simp_1_1 | Mathlib.Analysis.PSeries | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n |
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α] (x : αᵐᵒᵖ), 1 * x = x |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M) (h : p ≤ q), (Submodule.inclusion h).range = Submodule.comap q.subtype p |
MulEquiv.AddMonoid.End._proof_1 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {M : Type u_1} [inst : AddMonoid M] (x x_1 : AddMonoid.End M),
AddMonoidHom.toMultiplicative.toFun (x * x_1) = AddMonoidHom.toMultiplicative.toFun (x * x_1) |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {X Y : CategoryTheory.Under R} (f : X ⟶ Y),
((R.tensorProd S).map f).right =
CommRingCat.ofHom ↑(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom f)) |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {α : Sort u_1} (c0 c1 : Bool) {a b : α}, (bif c0 then a else bif c1 then a else b) = bif !c0 && !c1 then b else a |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
[inst : IsWellOrder β s] [inst_1 : IsTrans γ t] (f : InitialSeg r s) (g : PrincipalSeg s t) (a : α),
(f.transPrincipal g).toRelEmbedding a = g.toRelEmbedding (f a) |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_3, max u_2 u_3} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (x x_1 : J)
(f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const J).obj
(ModuleCat.of R
(CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (ModuleCat R)))).pt)).map
f)
(ModuleCat.ofHom (ModuleCat.limitπLinearMap F x_1)) =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (ModuleCat.limitπLinearMap F x)) (F.map f) |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_16} {Ms : η → Type u_17} {Ns : η → Type u_18} [inst : (j : η) → Mul (Ms j)]
[inst_1 : (j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j),
(MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L)
{K' : LieSubalgebra R L} (h : K ≤ K'),
(∃ I, LieIdeal.toLieSubalgebra R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : [] ≠ [] → Prop) (h : [] ≠ []), motive h |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.LinearMap | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_2} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → {p : Submodule R M} → [T1Space ↥p] → p.ClosedComplemented → Submodule R M |
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | ∀ (f : Type u₀ → Type u₁) [inst : EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α),
(EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a.bit1.testBit 0 = true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(__discr : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((header : Lean.TSyntax `Lean.Parser.Module.header) →
(parserState : Lean.Parser.ModuleParserState) →
(messages : Lean.MessageLog) → motive (header, parserState, messages)) →
motive __discr |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C}
(g h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F] {L : E →L[𝕜] E' →L[𝕜] F}
[inst_7 : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_8 : NormedSpace ℝ F] [inst_9 : AddGroup G],
MeasureTheory.convolution f 0 L μ = 0 |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
X.ofLEMk f h =
CategoryTheory.CategoryStruct.comp (X.ofLE (CategoryTheory.Subobject.mk f) h)
(CategoryTheory.Subobject.underlyingIso f).hom |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | ∀ {ι : Type u_1} {s : Finset ι} (motive : Subtype (Membership.mem s) → Prop) (x : Subtype (Membership.mem s)),
(∀ (i : ι) (hi : i ∈ s), motive ⟨i, hi⟩) → motive x |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List α |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] {m : M} (motive : IsAddUnit m → Prop) (h : IsAddUnit m),
(∀ (u : AddUnits M) (hu : ↑u = m), motive ⋯) → motive h |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : DivInvMonoid α], ULift.divInvMonoid = Function.Injective.divInvMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | ∀ {M : Type u} [inst : Monoid M] {F : Type v} [inst_1 : Field F] [inst_2 : MulSemiringAction M F] {S : Subfield F},
(∀ (m : M) {x : F}, x ∈ S → m • x ∈ S) → IsInvariantSubfield M S |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | ∀ (toBaseRuleSet : Aesop.BaseRuleSet) (simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems))
(simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size) (simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs))
(simprocsArrayNonempty : 0 < simprocsArray.size) (localNormSimpRules : Array Aesop.LocalNormSimpRule),
sizeOf
{ toBaseRuleSet := toBaseRuleSet, simpTheoremsArray := simpTheoremsArray,
simpTheoremsArrayNonempty := simpTheoremsArrayNonempty, simprocsArray := simprocsArray,
simprocsArrayNonempty := simprocsArrayNonempty, localNormSimpRules := localNormSimpRules } =
1 + sizeOf toBaseRuleSet + sizeOf simpTheoremsArray + sizeOf simpTheoremsArrayNonempty + sizeOf simprocsArray +
sizeOf simprocsArrayNonempty +
sizeOf localNormSimpRules |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | Lean.Syntax |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | {α : Type u_1} → (k : ℕ) → (Vector3 α k → Prop) → Prop |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α},
(t.erase k).isEmpty = false →
¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : C} (e : A ≅ B) (X : CategoryTheory.MonoOver A),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoOver.map e.hom).map
(((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.MonoOver.mapId A).symm.hom.app
X))
(((CategoryTheory.MonoOver.mapComp e.inv e.hom).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.MonoOver.mapId B).hom.app
((CategoryTheory.MonoOver.map e.hom).obj X)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.MonoOver.map e.hom).obj X) |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
0 ≤ a → ∀ (n : ℕ), (0 ≤ a ^ n) = True |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | ∀ {α : Type u} {motive : List α → Sort u_1} (t : List α) (nil : motive [])
(«else» : Nat.hasNotBit 1 t.ctorIdx → motive t) (h : Nat.hasNotBit 1 t.ctorIdx),
Lean.Data.AC.evalList._sparseCasesOn_1 t nil «else» = «else» h |
Int.le_of_not_le | Init.Data.Int.Order | ∀ {a b : ℤ}, ¬a ≤ b → b ≤ a |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
[inst : Preorder α] → [inst_1 : TopologicalSpace α] → [Topology.IsLowerSet α] → Topology.WithLowerSet α ≃ₜ α |
Nat.eq_or_lt_of_le._unsafe_rec | Init.Prelude | ∀ {n m : ℕ}, n ≤ m → n = m ∨ n < m |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → self.Set → ShareCommon.Object → Option ShareCommon.Object |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {a b : α} [inst : DecidableEq α], a ≠ b → (Equiv.swap a b).IsCycleOn {a, b} |
Mathlib.Tactic.Ring.evalZSMul._proof_2 | Mathlib.Tactic.Ring.Common | ∀ {u : Lean.Level} {α : Q(Type u)} (sα : Q(CommSemiring «$α»)), «$sα» =Q Int.instCommSemiring |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.