name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Grind.CommRing.Expr.below | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} → Lean.Grind.CommRing.Expr → Sort (max 1 u) |
_private.Init.Data.List.Monadic.0.List.allM.eq_1 | Init.Data.List.Monadic | ∀ {m : Type → Type u} [inst : Monad m] {α : Type v} (p : α → m Bool), List.allM p [] = pure true |
_private.Lean.Environment.0.Lean.instReprConstantKind.repr.match_1 | Lean.Environment | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) →
(Unit → motive Lean.ConstantKind.defn) →
(Unit → motive Lean.ConstantKind.thm) →
(Unit → motive Lean.ConstantKind.axiom) →
(Unit → motive Lean.ConstantKind.opaque) →
(Unit → motive Lean.ConstantKind.quot) →
(Unit → motive Lean.ConstantKind.induct) →
(Unit → motive Lean.ConstantKind.ctor) → (Unit → motive Lean.ConstantKind.recursor) → motive x |
ProfiniteGrp.ContinuousMulEquiv.toProfiniteGrpIso._proof_1._to_additive_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, CompactSpace ↑X.toProfinite.toTop |
_private.Mathlib.Data.Nat.Totient.0.ZMod.card_units_eq_totient._simp_1_2 | Mathlib.Data.Nat.Totient | ∀ {α : Type u_1} [inst : AddCommMonoid α] (f : ℕ → α) (n : ℕ), ∑ i ∈ Finset.range n, f i = ∑ i, f ↑i |
NormedAddGroupHom.ext_iff | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
{f g : NormedAddGroupHom V₁ V₂}, f = g ↔ ∀ (x : V₁), f x = g x |
USize.lt_or_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), a < b ∨ b ≤ a |
CategoryTheory.Pretriangulated.id_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₃ = CategoryTheory.CategoryStruct.id A.obj₃ |
CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_counitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D],
(CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).counitIso =
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.counitIso |
RatFunc.toFractionRingAlgEquiv._proof_1 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K] [inst_1 : IsDomain K] (R : Type u_2) [inst_2 : CommSemiring R]
[inst_3 : Algebra R (Polynomial K)] (r : R),
(RatFunc.toFractionRingRingEquiv K).toFun ((algebraMap R (RatFunc K)) r) =
(algebraMap R (FractionRing (Polynomial K))) r |
Set.indicator_comp_of_zero | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} {N : Type u_4} [inst : Zero M] [inst_1 : Zero N] {s : Set α} {f : α → M} {g : M → N},
g 0 = 0 → s.indicator (g ∘ f) = g ∘ s.indicator f |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_diff_add_size_inter_eq_size_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{h h' : Lean.Expr} →
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h = Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h' →
(h = h' → P) → P |
_private.Init.Data.UInt.Bitwise.0.UInt16.toUInt32_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ (a : UInt16) (b : UInt32), (a.toUInt32 = b % 65536) = (a = b.toUInt16) |
Submonoid.centralizer_eq_top_iff_subset | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ {M : Type u_1} [inst : Monoid M] {s : Set M}, Submonoid.centralizer s = ⊤ ↔ s ⊆ ↑(Submonoid.center M) |
TrivSqZeroExt.nonAssocSemiring._proof_7 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] (x₁ x₂ x₃ : TrivSqZeroExt R M), (x₁ + x₂) * x₃ = x₁ * x₃ + x₂ * x₃ |
NumberField.hermiteTheorem.rankOfDiscrBdd | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ℕ → ℕ |
RingSubgroupsBasis.mk | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {A : Type u_1} {ι : Type u_2} [inst : Ring A] {B : ι → AddSubgroup A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) →
(∀ (x : A) (i : ι), ∃ j, ↑(B j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(B i)) →
(∀ (x : A) (i : ι), ∃ j, ↑(B j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(B i)) → RingSubgroupsBasis B |
inTangentCoordinates_eq_mfderiv_comp | Mathlib.Geometry.Manifold.MFDeriv.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] {E' : Type u_5}
[inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_9 : TopologicalSpace H']
{I' : ModelWithCorners 𝕜 E' H'} {M' : Type u_7} [inst_10 : TopologicalSpace M'] [inst_11 : ChartedSpace H' M']
[inst_12 : IsManifold I' 1 M'] {N : Type u_8} {f : N → M} {g : N → M'}
{ϕ : (x : N) → TangentSpace I (f x) →L[𝕜] TangentSpace I' (g x)} {x₀ x : N},
f x ∈ (chartAt H (f x₀)).source →
g x ∈ (chartAt H' (g x₀)).source →
inTangentCoordinates I I' f g ϕ x₀ x =
(mfderiv% ↑(extChartAt I' (g x₀)) (g x)).comp
((ϕ x).comp
(mfderivWithin (modelWithCornersSelf 𝕜 E) I (↑(extChartAt I (f x₀)).symm) (Set.range ↑I)
(↑(extChartAt I (f x₀)) (f x)))) |
nilradical_eq_bot_iff | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_3} [inst : CommSemiring R], nilradical R = ⊥ ↔ IsReduced R |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.killCopies_eq_left._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x |
CategoryTheory.ULiftHom.objUp | Mathlib.CategoryTheory.Category.ULift | {C : Type u_1} → C → CategoryTheory.ULiftHom C |
minpoly.ofSubring | Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (A : Subring K)
[IsIntegrallyClosed ↥A] [IsFractionRing (↥A) K] (x : ↥(integralClosure (↥A) L)),
Polynomial.map (algebraMap (↥A) K) (minpoly (↥A) x) = minpoly K ↑x |
Std.Time.Database.TZdb.ctorIdx | Std.Time.Zoned.Database.TZdb | Std.Time.Database.TZdb → ℕ |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.handleRequest.match_1 | Lean.Server.Watchdog | (motive : Option Lean.Server.Watchdog.FileWorker → Sort u_1) →
(__do_lift : Option Lean.Server.Watchdog.FileWorker) →
(Unit → motive none) → ((x : Option Lean.Server.Watchdog.FileWorker) → motive x) → motive __do_lift |
Subgroup.exists_finsupp_of_mem_closure_range | Mathlib.Algebra.Group.Subgroup.Finsupp | ∀ {M : Type u_1} [inst : CommGroup M] {ι : Type u_2} (f : ι → M),
∀ x ∈ Subgroup.closure (Set.range f), ∃ a, x = a.prod fun x1 x2 => f x1 ^ x2 |
PiNat.mem_cylinder_iff._simp_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, (y ∈ PiNat.cylinder x n) = ∀ i < n, y i = x i |
PowerBasis.ofAdjoinEqTop | Mathlib.RingTheory.Adjoin.PowerBasis | {K : Type u_1} →
{S : Type u_2} →
[inst : Field K] →
[inst_1 : CommRing S] →
[inst_2 : Algebra K S] → {x : S} → IsIntegral K x → Algebra.adjoin K {x} = ⊤ → PowerBasis K S |
ZeroAtInftyContinuousMap.instSeminormedAddCommGroup._proof_4 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
(x x_1 : ZeroAtInftyContinuousMap α β),
{ toFun := ZeroAtInftyContinuousMap.toBCF, map_zero' := ⋯ }.toFun (x + x_1) =
{ toFun := ZeroAtInftyContinuousMap.toBCF, map_zero' := ⋯ }.toFun (x + x_1) |
SimpleGraph.isVertexCover_image_iso | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} (f : G ≃g H) {c : Set V},
H.IsVertexCover (⇑f '' c) ↔ G.IsVertexCover c |
CategoryTheory.Limits.HasFiniteWidePullbacks.out | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Limits.HasFiniteWidePullbacks C]
(J : Type) [Finite J], CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.ctorIdx | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {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} →
{inst_4 : CategoryTheory.MonoidalClosed V} →
{F G H : CategoryTheory.Functor C V} → CategoryTheory.MonoidalCategory.DayConvolutionInternalHom F G H → ℕ |
CategoryTheory.Limits.BinaryBiproductData.casesOn | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
{motive : CategoryTheory.Limits.BinaryBiproductData P Q → Sort u} →
(t : CategoryTheory.Limits.BinaryBiproductData P Q) →
((bicone : CategoryTheory.Limits.BinaryBicone P Q) →
(isBilimit : bicone.IsBilimit) → motive { bicone := bicone, isBilimit := isBilimit }) →
motive t |
Turing.FinTM2.step.eq_1 | Mathlib.Computability.TuringMachine.Computable | ∀ (tm : Turing.FinTM2), tm.step = Turing.TM2.step tm.m |
Lean.Elab.Term.Do.Code.matchExpr.sizeOf_spec | Lean.Elab.Do.Legacy | ∀ (ref : Lean.Syntax) («meta» : Bool) (discr : Lean.Syntax)
(alts : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) (elseBranch : Lean.Elab.Term.Do.Code),
sizeOf (Lean.Elab.Term.Do.Code.matchExpr ref «meta» discr alts elseBranch) =
1 + sizeOf ref + sizeOf «meta» + sizeOf discr + sizeOf alts + sizeOf elseBranch |
NormedCommGroup.mk | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
[toNorm : Norm E] →
[toCommGroup : CommGroup E] →
[toMetricSpace : MetricSpace E] →
autoParam (∀ (x y : E), dist x y = ‖x⁻¹ * y‖) NormedCommGroup.dist_eq._autoParam → NormedCommGroup E |
Mathlib.Tactic.ComputeDegree.initFn._@.Mathlib.Tactic.ComputeDegree.1830119225._hygCtx._hyg.2 | Mathlib.Tactic.ComputeDegree | IO Unit |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_5 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f g : α → β} {s : Set α} {a : α},
(f =ᶠ[nhdsWithin a s] g) = ∀ᶠ (x : α) in nhds a, x ∈ s → f x = g x |
BitVec.lt_asymm | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x < y → ¬y < x |
FirstOrder.Language.DirectLimit.dom_partialEquivLimit | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N] {ι : Type u_1}
[inst_2 : Preorder ι] [inst_3 : Nonempty ι] [inst_4 : IsDirectedOrder ι] (S : ι →o L.PartialEquiv M N),
(FirstOrder.Language.DirectLimit.partialEquivLimit S).dom = ⨆ x, (S x).dom |
Nat.minSqFacAux_has_prop._unary | Mathlib.Data.Nat.Squarefree | ∀ (_x : (n : ℕ) ×' (k : ℕ) ×' (_ : 0 < n) ×' (i : ℕ) ×' (_ : k = 2 * i + 3) ×' ∀ (m : ℕ), Nat.Prime m → m ∣ n → k ≤ m),
_x.1.MinSqFacProp (_x.1.minSqFacAux _x.2.1) |
Order.pred_lt | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a < a |
UInt8.xor_comm | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), a ^^^ b = b ^^^ a |
TopologicalSpace.Compacts.ext | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : TopologicalSpace.Compacts α}, ↑s = ↑t → s = t |
CategoryTheory.Functor.IsCartesian | Mathlib.CategoryTheory.FiberedCategory.Cartesian | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
CategoryTheory.Functor 𝒳 𝒮 → {R S : 𝒮} → {a b : 𝒳} → (R ⟶ S) → (a ⟶ b) → Prop |
Mathlib.Meta.NormNum.minFacHelper_2 | Mathlib.Tactic.NormNum.Prime | ∀ {n k k' : ℕ},
k + 2 = k' → ¬Nat.Prime k → Mathlib.Meta.NormNum.MinFacHelper n k → Mathlib.Meta.NormNum.MinFacHelper n k' |
_private.Mathlib.Analysis.InnerProductSpace.Coalgebra.0.InnerProductSpace.ringOfCoalgebra._simp_8 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Coalgebra R A],
LinearMap.rTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul =
↑(TensorProduct.assoc R A A A).symm ∘ₗ LinearMap.lTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul |
Equiv.smulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : Zero B] [inst_1 : SMulZeroClass M B] (a : M),
a • 0 = 0 |
Std.TreeMap.Raw.filter | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → (α → β → Bool) → Std.TreeMap.Raw α β cmp → Std.TreeMap.Raw α β cmp |
finprod_cond_eq_right | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {a : α}, ∏ᶠ (i : α) (_ : a = i), f i = f a |
CategoryTheory.ShortComplex.quasiIso_unopMap | Mathlib.Algebra.Homology.ShortComplex.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex Cᵒᵖ} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
[inst_4 : S₁.unop.HasHomology] [inst_5 : S₂.unop.HasHomology] (φ : S₁ ⟶ S₂) [CategoryTheory.ShortComplex.QuasiIso φ],
CategoryTheory.ShortComplex.QuasiIso (CategoryTheory.ShortComplex.unopMap φ) |
Set.Ioc_disjoint_Ioi._simp_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] {a b c : α}, b ≤ c → Disjoint (Set.Ioc a b) (Set.Ioi c) = True |
EuclideanDomain.div_dvd_of_dvd | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {p q : R}, q ∣ p → p / q ∣ p |
MagmaCat.inv_hom_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N : MagmaCat} (e : M ≅ N) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x |
IsPrimitiveRoot.embeddingsEquivPrimitiveRoots.congr_simp | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] {K : Type u} {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ ζ_1 : L} (e_ζ : ζ = ζ_1) (hζ : IsPrimitiveRoot ζ n)
(C : Type u_1) [inst_6 : CommRing C] [inst_7 : IsDomain C] [inst_8 : Algebra K C]
(hirr : Irreducible (Polynomial.cyclotomic n K)),
hζ.embeddingsEquivPrimitiveRoots C hirr = ⋯.embeddingsEquivPrimitiveRoots C hirr |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.exists_true | Init.Grind.Module.Envelope | ∀ (α : Type u) [Lean.Grind.NatModule α], ∃ x, True |
_private.Mathlib.Algebra.Star.NonUnitalSubalgebra.0.NonUnitalStarSubalgebra.mem_centralizer_iff._simp_1_4 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.propagateForallPropUp.match_1 | Lean.Meta.Tactic.Grind.ForallProp | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (p q : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.forallE n p q bi)) →
((x : Lean.Expr) → motive x) → motive e |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.HasMFDerivAt.prodMap._simp_1_2 | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'},
mfderiv% f = mfderivWithin I I' f Set.univ |
min_left_comm | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : α), min a (min b c) = min b (min a c) |
ContinuousMap.HomotopyEquiv.trans._proof_2 | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (h₁ : ContinuousMap.HomotopyEquiv X Y) (h₂ : ContinuousMap.HomotopyEquiv Y Z),
((h₂.toFun.comp h₁.toFun).comp (h₁.invFun.comp h₂.invFun)).Homotopic (ContinuousMap.id Z) |
LinearMap.mul_toMatrix₂_mul | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {M₁' : Type u_8} {M₂' : Type u_9} {n : Type u_11} {m : Type u_12}
{n' : Type u_13} {m' : Type u_14} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] [inst_5 : Fintype n] [inst_6 : Fintype m] [inst_7 : DecidableEq m]
[inst_8 : DecidableEq n] (b₁ : Module.Basis n R M₁) (b₂ : Module.Basis m R M₂) [inst_9 : AddCommMonoid M₁']
[inst_10 : Module R M₁'] [inst_11 : AddCommMonoid M₂'] [inst_12 : Module R M₂'] (b₁' : Module.Basis n' R M₁')
(b₂' : Module.Basis m' R M₂') [inst_13 : Fintype n'] [inst_14 : Fintype m'] [inst_15 : DecidableEq n']
[inst_16 : DecidableEq m'] (B : M₁ →ₗ[R] M₂ →ₗ[R] R) (M : Matrix n' n R) (N : Matrix m m' R),
M * (LinearMap.toMatrix₂ b₁ b₂) B * N =
(LinearMap.toMatrix₂ b₁' b₂') (B.compl₁₂ ((Matrix.toLin b₁' b₁) M.transpose) ((Matrix.toLin b₂' b₂) N)) |
TestFunction.monoCLM_apply | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω₁ Ω₂ : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n₁ n₂ : ℕ∞} [inst_6 : Algebra ℝ 𝕜]
[inst_7 : IsScalarTower ℝ 𝕜 F] (f : TestFunction Ω₁ F n₁),
⇑((TestFunction.monoCLM 𝕜) f) = ⇑(if n₂ ≤ n₁ ∧ Ω₁ ≤ Ω₂ then f else 0) |
Lean.Elab.Level.instMonadRefLevelElabM | Lean.Elab.Level | Lean.MonadRef Lean.Elab.Level.LevelElabM |
DivisibleHull.instLinearOrder._proof_7 | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedCancelAddMonoid M]
(a b : DivisibleHull M), (if a ≤ b then b else a) = if a ≤ b then b else a |
Subring.closure_union | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : Ring R] (s t : Set R), Subring.closure (s ∪ t) = Subring.closure s ⊔ Subring.closure t |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Operations.0.SimpleGraph.Walk.ext_support._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p q : G.Walk u v},
p.support = q.support →
(Prod.fst ∘ SimpleGraph.Dart.toProd = fun d => d.toProd.1) →
(Prod.snd ∘ SimpleGraph.Dart.toProd = fun d => d.toProd.2) →
(List.map SimpleGraph.Dart.toProd p.darts).unzip = (List.map SimpleGraph.Dart.toProd q.darts).unzip |
LinearEquiv.funCongrLeft._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | ∀ (R : Type u_3) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {m : Type u_2}
{n : Type u_4} (e : m ≃ n), LinearMap.funLeft R M ⇑e ∘ₗ LinearMap.funLeft R M ⇑e.symm = LinearMap.id |
Quiver.FreeGroupoid.lift_spec | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | ∀ {V : Type u} [inst : Quiver V] {V' : Type u'} [inst_1 : CategoryTheory.Groupoid V'] (φ : V ⥤q V'),
Quiver.FreeGroupoid.of V ⋙q (Quiver.FreeGroupoid.lift φ).toPrefunctor = φ |
Int.one_bmod | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℕ}, 3 ≤ b → Int.bmod 1 b = 1 |
Std.Sat.AIG.RefVec.get_push_ref_eq' | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {len : ℕ} (s : aig.RefVec len)
(ref : aig.Ref) (idx : ℕ) (hidx : idx = len), (s.push ref).get idx ⋯ = ref |
Finset.prod_finset_product_right' | Mathlib.Algebra.BigOperators.Group.Finset.Sigma | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : CommMonoid β] (r : Finset (α × γ)) (s : Finset γ)
(t : γ → Finset α),
(∀ (p : α × γ), p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) → ∀ {f : α → γ → β}, ∏ p ∈ r, f p.1 p.2 = ∏ c ∈ s, ∏ a ∈ t c, f a c |
_private.Mathlib.Order.WithBot.0.WithBot.forall_coe_le_iff_le._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Preorder α] {x : WithBot α} [NoBotOrder α], (x = ⊥) = ∀ (b : α), x ≤ ↑b |
CategoryTheory.Bimon.ofMonComonObj_comon_counit_hom | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon (CategoryTheory.Comon C)),
CategoryTheory.ComonObj.counit.hom = CategoryTheory.ComonObj.counit |
Aesop.Goal.traceTreeCore | Aesop.Tree.Tracing | Aesop.Goal → Aesop.TraceOption → Lean.MetaM Unit |
CategoryTheory.Functor.ShiftSequence.shiftIso_zero | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} A} {F : CategoryTheory.Functor C A} {M : Type u_3} {inst_2 : AddMonoid M}
{inst_3 : CategoryTheory.HasShift C M} [self : F.ShiftSequence M] (a : M),
CategoryTheory.Functor.ShiftSequence.shiftIso 0 a a ⋯ =
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.shiftFunctorZero C M)
(CategoryTheory.Functor.ShiftSequence.sequence F a) ≪≫
(CategoryTheory.Functor.ShiftSequence.sequence F a).leftUnitor |
AddMonoidHom.restrictHom._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : AddZeroClass M] {S : Type u_3} [inst_1 : SetLike S M] [inst_2 : AddSubmonoidClass S M] (M' : S)
(A : Type u_2) [inst_3 : AddCommMonoid A] (x x_1 : M →+ A), (x + x_1).restrict M' = x.restrict M' + x_1.restrict M' |
Mathlib.Tactic.Monoidal.instMonadMor₂MonoidalM.match_3 | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | (motive : Option Mathlib.Tactic.BicategoryLike.IsoLift → Sort u_1) →
(x : Option Mathlib.Tactic.BicategoryLike.IsoLift) →
((η_iso : Mathlib.Tactic.BicategoryLike.IsoLift) → motive (some η_iso)) →
((x : Option Mathlib.Tactic.BicategoryLike.IsoLift) → motive x) → motive x |
Option.get_bind | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : Option α} {f : α → Option β} (h : (x.bind f).isSome = true),
(x.bind f).get h = (f (x.get ⋯)).get ⋯ |
Lean.Server.Reference.mk.noConfusion | Lean.Server.References | {P : Sort u} →
{ident : Lean.Lsp.RefIdent} →
{aliases : Array Lean.Lsp.RefIdent} →
{range : Lean.Lsp.Range} →
{stx : Lean.Syntax} →
{ci : Lean.Elab.ContextInfo} →
{info : Lean.Elab.Info} →
{isBinder : Bool} →
{ident' : Lean.Lsp.RefIdent} →
{aliases' : Array Lean.Lsp.RefIdent} →
{range' : Lean.Lsp.Range} →
{stx' : Lean.Syntax} →
{ci' : Lean.Elab.ContextInfo} →
{info' : Lean.Elab.Info} →
{isBinder' : Bool} →
{ ident := ident, aliases := aliases, range := range, stx := stx, ci := ci, info := info,
isBinder := isBinder } =
{ ident := ident', aliases := aliases', range := range', stx := stx', ci := ci',
info := info', isBinder := isBinder' } →
(ident = ident' →
aliases = aliases' →
range = range' →
stx = stx' → ci = ci' → info = info' → isBinder = isBinder' → P) →
P |
Algebra.cardinalMk_adjoin_le | Mathlib.Algebra.FreeAlgebra.Cardinality | ∀ (R : Type u) [inst : CommSemiring R] {A : Type u} [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A),
Cardinal.mk ↥(Algebra.adjoin R s) ≤ max (max (Cardinal.mk R) (Cardinal.mk ↑s)) Cardinal.aleph0 |
CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso_hom_app_snd_snd | Mathlib.CategoryTheory.Sums.Products | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {A' : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] {B : Type u} [inst_2 : CategoryTheory.Category.{v, u} B]
(T : Type u_3) [inst_3 : CategoryTheory.Category.{v_3, u_3} T] (X : CategoryTheory.Functor ((A ⊕ A') ⊕ T) B),
((CategoryTheory.Sum.associativityFunctorEquivNaturalityFunctorIso T).hom.app X).2.2 =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Sum.inr_ A' T).whiskerLeft
((CategoryTheory.Sum.inr_ A (A' ⊕ T)).associator (CategoryTheory.sum.inverseAssociator A A' T) X).inv)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Sum.inr_ A' T).associator
((CategoryTheory.Sum.inr_ A (A' ⊕ T)).comp (CategoryTheory.sum.inverseAssociator A A' T)) X).inv
(CategoryTheory.Functor.whiskerRight (CategoryTheory.sum.inrCompInrCompInverseAssociator A A' T).hom X)) |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.ENNReal.continuous_pow._simp_1_5 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {a : ENNReal} {n : ℕ}, (a ^ n = ⊤) = (a = ⊤ ∧ n ≠ 0) |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
(𝒰 : S.OpenCover) →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] → Type (max (max (u + 1) u_1) u_2) |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.properSMul_iff_continuousSMul_ultrafilter_tendsto.match_1_1 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {G : Type u_1} {X : Type u_2} [inst : Group G] [inst_1 : MulAction G X] [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace X]
(motive :
(ContinuousSMul G X ∧
∀ (𝒰 : Ultrafilter (G × X)) (x₁ x₂ : X),
Filter.Tendsto (fun gx => (gx.1 • gx.2, gx.2)) (↑𝒰) (nhds (x₁, x₂)) →
∃ g, g • x₂ = x₁ ∧ Filter.Tendsto Prod.fst (↑𝒰) (nhds g)) →
Prop)
(x :
ContinuousSMul G X ∧
∀ (𝒰 : Ultrafilter (G × X)) (x₁ x₂ : X),
Filter.Tendsto (fun gx => (gx.1 • gx.2, gx.2)) (↑𝒰) (nhds (x₁, x₂)) →
∃ g, g • x₂ = x₁ ∧ Filter.Tendsto Prod.fst (↑𝒰) (nhds g)),
(∀ (cont : ContinuousSMul G X)
(h :
∀ (𝒰 : Ultrafilter (G × X)) (x₁ x₂ : X),
Filter.Tendsto (fun gx => (gx.1 • gx.2, gx.2)) (↑𝒰) (nhds (x₁, x₂)) →
∃ g, g • x₂ = x₁ ∧ Filter.Tendsto Prod.fst (↑𝒰) (nhds g)),
motive ⋯) →
motive x |
Lean.Grind.Field.mk.noConfusion | Init.Grind.Ring.Field | {α : Type u} →
{P : Sort u_1} →
{toCommRing : Lean.Grind.CommRing α} →
{toInv : Inv α} →
{toDiv : Div α} →
{zpow : HPow α ℤ α} →
{div_eq_mul_inv : ∀ (a b : α), a / b = a * b⁻¹} →
{zero_ne_one : 0 ≠ 1} →
{inv_zero : 0⁻¹ = 0} →
{mul_inv_cancel : ∀ {a : α}, a ≠ 0 → a * a⁻¹ = 1} →
{zpow_zero : ∀ (a : α), a ^ 0 = 1} →
{zpow_succ : ∀ (a : α) (n : ℕ), a ^ (↑n + 1) = a ^ ↑n * a} →
{zpow_neg : ∀ (a : α) (n : ℤ), a ^ (-n) = (a ^ n)⁻¹} →
{toCommRing' : Lean.Grind.CommRing α} →
{toInv' : Inv α} →
{toDiv' : Div α} →
{zpow' : HPow α ℤ α} →
{div_eq_mul_inv' : ∀ (a b : α), a / b = a * b⁻¹} →
{zero_ne_one' : 0 ≠ 1} →
{inv_zero' : 0⁻¹ = 0} →
{mul_inv_cancel' : ∀ {a : α}, a ≠ 0 → a * a⁻¹ = 1} →
{zpow_zero' : ∀ (a : α), a ^ 0 = 1} →
{zpow_succ' : ∀ (a : α) (n : ℕ), a ^ (↑n + 1) = a ^ ↑n * a} →
{zpow_neg' : ∀ (a : α) (n : ℤ), a ^ (-n) = (a ^ n)⁻¹} →
{ toCommRing := toCommRing, toInv := toInv, toDiv := toDiv,
zpow := zpow, div_eq_mul_inv := div_eq_mul_inv,
zero_ne_one := zero_ne_one, inv_zero := inv_zero,
mul_inv_cancel := mul_inv_cancel, zpow_zero := zpow_zero,
zpow_succ := zpow_succ, zpow_neg := zpow_neg } =
{ toCommRing := toCommRing', toInv := toInv', toDiv := toDiv',
zpow := zpow', div_eq_mul_inv := div_eq_mul_inv',
zero_ne_one := zero_ne_one', inv_zero := inv_zero',
mul_inv_cancel := mul_inv_cancel', zpow_zero := zpow_zero',
zpow_succ := zpow_succ', zpow_neg := zpow_neg' } →
(toCommRing ≍ toCommRing' →
toInv ≍ toInv' → toDiv ≍ toDiv' → zpow ≍ zpow' → P) →
P |
Valued.valueGroup₀_equiv_extensionValuation | Mathlib.Topology.Algebra.Valued.ValuedField | {K : Type u_1} →
[inst : Field K] →
{Γ₀ : Type u_2} →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
[hv : Valued K Γ₀] →
MonoidWithZeroHom.ValueGroup₀ Valued.v ≃* MonoidWithZeroHom.ValueGroup₀ Valued.extensionValuation |
PrimeSpectrum.piLocalizationToMaximal_bijective | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {R : Type u_1} [inst : CommSemiring R],
(∀ (I : Ideal R), I.IsPrime → I.IsMaximal) → Function.Bijective ⇑(PrimeSpectrum.piLocalizationToMaximal R) |
Lean.Elab.Command.ElabHeaderResult.indFVar | Lean.Elab.MutualInductive | Lean.Elab.Command.ElabHeaderResult → Lean.Expr |
Lean.Order.ReverseImplicationOrder.instCompleteLattice | Init.Internal.Order.Basic | Lean.Order.CompleteLattice Lean.Order.ReverseImplicationOrder |
BoxIntegral.Prepartition.iUnion_disjUnion | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (h : Disjoint π₁.iUnion π₂.iUnion),
(π₁.disjUnion π₂ h).iUnion = π₁.iUnion ∪ π₂.iUnion |
CFC.exp_log | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : StarRing A] [inst_2 : NormedAlgebra ℝ A]
[inst_3 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_4 : PartialOrder A] [StarOrderedRing A]
[NonnegSpectrumClass ℝ A] (a : A),
autoParam (IsStrictlyPositive a) CFC.exp_log._auto_1 → NormedSpace.exp (CFC.log a) = a |
Primrec.option_guard | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : α → β → Prop}
[inst_2 : DecidableRel p],
PrimrecRel p → ∀ {f : α → β}, Primrec f → Primrec fun a => Option.guard (fun b => decide (p a b)) (f a) |
Subsemigroup.centerCongr_symm_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : Mul M] [inst_1 : Mul N] (e : M ≃* N) (s : ↥(Subsemigroup.center N)),
↑((Subsemigroup.centerCongr e).symm s) = e.symm ↑s |
TopologicalSpace.ext_iff_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u_2} {t t' : TopologicalSpace X}, t = t' ↔ ∀ (x : X), nhds x = nhds x |
Lean.KeyedDeclsAttribute.AttributeEntry.mk.sizeOf_spec | Lean.KeyedDeclsAttribute | ∀ {γ : Type} [inst : SizeOf γ] (toOLeanEntry : Lean.KeyedDeclsAttribute.OLeanEntry) (isBuiltin : Bool) (value : γ),
sizeOf { toOLeanEntry := toOLeanEntry, isBuiltin := isBuiltin, value := value } =
1 + sizeOf toOLeanEntry + sizeOf isBuiltin + sizeOf value |
Stream'.cons.match_1 | Mathlib.Data.Stream.Defs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
HomologicalComplex.truncGEXIsoOpcycles | Mathlib.Algebra.Homology.Embedding.TruncGE | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(K : HomologicalComplex C c') →
(e : c.Embedding c') →
[inst_2 : e.IsTruncGE] →
[inst_3 : ∀ (i' : ι'), K.HasHomology i'] →
[inst_4 : CategoryTheory.Limits.HasZeroObject C] →
{i : ι} → {i' : ι'} → e.f i = i' → e.BoundaryGE i → ((K.truncGE e).X i' ≅ K.opcycles i') |
CircleDeg1Lift.strictMono_iff_injective | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), StrictMono ⇑f ↔ Function.Injective ⇑f |
AddEquiv.toIntLinearEquiv_refl | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_5} [inst : AddCommGroup M] {modM : Module ℤ M}, (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.