name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
fderivWithin_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {𝔸' : Type u_6} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {c d : E → 𝔸'},
UniqueDiffWithinAt 𝕜 s x →
DifferentiableWithinAt 𝕜 c s x →
DifferentiableWithinAt 𝕜 d s x →
fderivWithin 𝕜 (c * d) s x = c x • fderivWithin 𝕜 d s x + d x • fderivWithin 𝕜 c s x | true |
lt_norm_sub_of_not_sameRay | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [StrictConvexSpace ℝ E] {x y : E},
¬SameRay ℝ x y → ‖x‖ - ‖y‖ < ‖x - y‖ | true |
AddValuation.map_le_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R} {g : Γ₀}, g ≤ v x → g ≤ v y → g ≤ v (x - y) | true |
CategoryTheory.Limits.preservesFiniteLimits_of_preservesEqualizers_and_finiteProducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Limits.HasFiniteProducts C] (G : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingParallelPair G]
[CategoryTheory.Limits.PreservesFiniteProducts G], CategoryTheory.Limits.PreservesFiniteLimits G | true |
FormalMultilinearSeries.leftInv.eq_def | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : 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]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E) (x_1 : ℕ),
p.leftInv i x x_1 =
match x_1 with
| 0 => ContinuousMultilinearMap.uncurry0 𝕜 F x
| 1 => (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm
| n.succ.succ =>
-∑ c,
ContinuousMultilinearMap.compAlongComposition (p.compContinuousLinearMap ↑i.symm) (↑c)
(p.leftInv i x (↑c).length) | true |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ)
{X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : Cᵒᵖ} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app Y) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.opShiftFunctorEquivalence C n).unitIso.inv.app X) f)
h | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_11 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Lean.Server.Ilean.version | Lean.Server.References | Lean.Server.Ilean → ℕ | true |
Nat.mul_sub_left_distrib | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m - k) = n * m - n * k | true |
Action.ofMulActionLimitCone._proof_3 | Mathlib.CategoryTheory.Action.Concrete | ∀ {ι : Type u_2} (G : Type (max u_2 u_1)) [inst : Monoid G] (F : ι → Type (max u_2 u_1))
[inst_1 : (i : ι) → MulAction G (F i)] (i : CategoryTheory.Discrete ι) (x : G),
(CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Functor.const (CategoryTheory.Discrete ι)).obj (Action.ofMulAction G ((i : ι) → F i))).obj i).ρ
x)
fun x => x i.as) =
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Functor.const (CategoryTheory.Discrete ι)).obj (Action.ofMulAction G ((i : ι) → F i))).obj i).ρ
x)
fun x => x i.as | false |
_private.Batteries.Data.Char.Basic.0.Char.toNat_not_surrogate._proof_1_3 | Batteries.Data.Char.Basic | ∀ (c : Char), c.toNat < 55296 → ¬(55296 ≤ c.toNat ∧ c.toNat ≤ 57343) | false |
Int.reduceGE._regBuiltin.Int.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1458257035._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
AddGroup.addRight_bijective | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), Function.Bijective fun x => x + a | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabTermAux | Lean.Elab.Term.TermElabM | Option Lean.Expr → Bool → Bool → Lean.Syntax → Lean.Elab.TermElabM Lean.Expr | true |
UInt32.toBitVec_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), (a ^^^ b).toBitVec = a.toBitVec ^^^ b.toBitVec | true |
CategoryTheory.Bicategory.Adjunction | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} → [inst : CategoryTheory.Bicategory B] → {a b : B} → (a ⟶ b) → (b ⟶ a) → Type w | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvType._sparseCasesOn_4 | Lean.Compiler.LCNF.AlphaEqv | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | false |
MeasureTheory.aecover_Ioc_of_Icc | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [OrderClosedTopology α] [OpensMeasurableSpace α] {a b : ι → α}
{A B : α} [MeasureTheory.NoAtoms μ],
Filter.Tendsto a l (nhds A) →
Filter.Tendsto b l (nhds B) → MeasureTheory.AECover (μ.restrict (Set.Ioc A B)) l fun i => Set.Icc (a i) (b i) | true |
WithBot.decidableLT.eq_3 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [inst_1 : DecidableLT α] (a b : α),
WithBot.decidableLT (some a) (some b) = decidable_of_iff' (a < b) ⋯ | true |
CategoryTheory.Limits.IsZero.iso | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → CategoryTheory.Limits.IsZero X → CategoryTheory.Limits.IsZero Y → (X ≅ Y) | true |
MeasureTheory.unifTight_iff_real | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ ⦃ε : ℝ⦄, 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ENNReal.ofReal ε | true |
Module.End.eq_zero_of_isNilpotent_isSemisimple | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, IsNilpotent f → f.IsSemisimple → f = 0 | true |
CategoryTheory.InitialModel | Mathlib.CategoryTheory.Limits.FinallySmall | (J : Type u) → [inst : CategoryTheory.Category.{v, u} J] → [CategoryTheory.InitiallySmall J] → Type w | true |
_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.Collector.visit._sparseCasesOn_4 | Lean.Meta.Tactic.FunIndCollect | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((typeName : Lean.Name) →
(idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 3568 t.ctorIdx → motive t) → motive t | false |
Stream'.Seq.take.eq_def | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (x : ℕ) (x_1 : Stream'.Seq α),
Stream'.Seq.take x x_1 =
match x, x_1 with
| 0, x => []
| n.succ, s =>
match s.destruct with
| none => []
| some (x, r) => x :: Stream'.Seq.take n r | true |
BoundedContinuousFunction.instIntCast | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{β : Type u_2} → [inst_1 : PseudoMetricSpace β] → [IntCast β] → IntCast (BoundedContinuousFunction α β) | true |
WellFounded.isAsymm | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop}, WellFounded r → Std.Asymm r | true |
_private.Mathlib.AlgebraicGeometry.OpenImmersion.0.AlgebraicGeometry.IsOpenImmersion.of_isIso_stalkMap._proof_1_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
[∀ (x : ↥X), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x)] (x : ↥X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap f.toShHom.hom x) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w ∧ -2 ^ w ≤ x.toInt * y.toInt → ¬-(2 ^ (w + 1) / 2) ≤ x.toInt * y.toInt → False | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence.0.groupCohomology.map_cochainsFunctor_shortExact._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact = ((ModuleCat.Hom.hom S.f).range = (ModuleCat.Hom.hom S.g).ker) | false |
Std.Internal.List.getValueD_insertListConst_of_mem | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)} {k k' : α}
{v fallback : β},
Std.Internal.List.DistinctKeys l →
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) toInsert →
(k, v) ∈ toInsert → Std.Internal.List.getValueD k' (Std.Internal.List.insertListConst l toInsert) fallback = v | true |
CategoryTheory.SimplicialObject.Augmented.rightOp_left | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C),
X.rightOp.left = Opposite.op X.right | true |
FreeSimplexQuiver.homRel.rec | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop},
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ j.castSucc),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.castSucc)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
⋯) →
∀ ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
motive a a_1 t | false |
IsStarProjection.add | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p q : R} [inst : NonUnitalNonAssocSemiring R] [inst_1 : StarRing R],
IsStarProjection p → IsStarProjection q → p * q = 0 → IsStarProjection (p + q) | true |
NonUnitalAlgHom.equalizer._proof_3 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {F : Type u_3} {R : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B]
[inst_4 : Module R B] [inst_5 : FunLike F A B] [NonUnitalAlgHomClass F R A B] (ϕ ψ : F) {x y : A},
ϕ x = ψ x → ϕ y = ψ y → x * y ∈ {a | ϕ a = ψ a} | false |
Lean.PrettyPrinter.Formatter.checkTailWs.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | true |
_private.Mathlib.Analysis.InnerProductSpace.LinearMap.0._aux_Mathlib_Analysis_InnerProductSpace_LinearMap___unexpand_Inner_inner_2 | Mathlib.Analysis.InnerProductSpace.LinearMap | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.«_aux_Mathlib_Data_Seq_Defs___macroRules__private_Mathlib_Data_Seq_Defs_0_Stream'_Seq_term_~__1» | Mathlib.Data.Seq.Defs | Lean.Macro | false |
MeasureTheory.lintegral_add_left | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
Measurable f → ∀ (g : α → ENNReal), ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ | true |
CategoryTheory.Enriched.HasConicalProducts.hasConicalLimitsOfShape | Mathlib.CategoryTheory.Enriched.Limits.HasConicalProducts | ∀ {V : outParam (Type u')} {inst : CategoryTheory.Category.{v', u'} V} {inst_1 : CategoryTheory.MonoidalCategory V}
{C : Type u} {inst_2 : CategoryTheory.Category.{v, u} C} {inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C}
[self : CategoryTheory.Enriched.HasConicalProducts V C] (J : Type w),
CategoryTheory.Enriched.HasConicalLimitsOfShape (CategoryTheory.Discrete J) V C | true |
MulActionHom.fst | Mathlib.GroupTheory.GroupAction.Hom | (M : Type u_1) → (α : Type u_2) → (β : Type u_3) → [inst : SMul M α] → [inst_1 : SMul M β] → α × β →ₑ[id] α | true |
Lean.Elab.Term.LValResolution.noConfusion | Lean.Elab.App | {P : Sort u} → {t t' : Lean.Elab.Term.LValResolution} → t = t' → Lean.Elab.Term.LValResolution.noConfusionType P t t' | false |
Lean.Grind.CommRing.Poly.powC_nc._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → ℕ → Lean.Grind.CommRing.Poly | false |
Std.Net.SocketAddressV6.mk._flat_ctor | Std.Net.Addr | Std.Net.IPv6Addr → UInt16 → Std.Net.SocketAddressV6 | false |
vectorSpan_eq_span_vsub_set_right_ne | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : Set P} {p : P},
p ∈ s → vectorSpan k s = Submodule.span k ((fun x => x -ᵥ p) '' (s \ {p})) | true |
Set.inter_preimage_subset | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β) (f : α → β), s ∩ f ⁻¹' t ⊆ f ⁻¹' (f '' s ∩ t) | true |
HomogeneousLocalization.awayMapₐ_apply | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] (𝒜 : ι → σ)
[inst_5 : GradedRing 𝒜] {e : ι} {f g : A} (hg : g ∈ 𝒜 e) {x : A} (hx : x = f * g)
(a : HomogeneousLocalization.Away 𝒜 f),
(HomogeneousLocalization.awayMapₐ 𝒜 hg hx) a = (HomogeneousLocalization.awayMap 𝒜 hg hx) a | true |
SimpleGraph.isClique_iff_induce_eq | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {s : Set α}, G.IsClique s ↔ SimpleGraph.induce s G = ⊤ | true |
Set.subset_sInter_iff | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ⊆ ⋂₀ S ↔ ∀ t' ∈ S, t ⊆ t' | true |
Lean.Order.instMonoBindOption | Init.Internal.Order.Basic | Lean.Order.MonoBind Option | true |
List.length_permutations | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (l : List α), l.permutations.length = l.length.factorial | true |
_private.Aesop.Search.Main.0.Aesop.search.match_1 | Aesop.Search.Main | (motive : Option Aesop.LocalRuleSet → Sort u_1) →
(ruleSet? : Option Aesop.LocalRuleSet) →
(Unit → motive none) → ((ruleSet : Aesop.LocalRuleSet) → motive (some ruleSet)) → motive ruleSet? | false |
Multiset.ndinsert_le | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s t : Multiset α}, Multiset.ndinsert a s ≤ t ↔ s ≤ t ∧ a ∈ t | true |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.exists_isLeast_one_lt._simp_1_1 | Mathlib.GroupTheory.Archimedean | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (a / c ≤ b) = (a ≤ b * c) | false |
Sylow.mapSurjective | Mathlib.GroupTheory.Sylow | {p : ℕ} →
{G : Type u_1} →
[inst : Group G] →
[Finite G] →
{G' : Type u_2} →
[inst_2 : Group G'] → {f : G →* G'} → Function.Surjective ⇑f → [Fact (Nat.Prime p)] → Sylow p G → Sylow p G' | true |
Nat.toList_roo_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : List ℕ} {m n a : ℕ}, ((m<...n).toList = a :: xs) = (m + 1 = a ∧ m + 1 < n ∧ ((m + 1)<...n).toList = xs) | false |
DistLat.Hom.rec | Mathlib.Order.Category.DistLat | {X Y : DistLat} →
{motive : X.Hom Y → Sort u_1} → ((hom' : LatticeHom ↑X ↑Y) → motive { hom' := hom' }) → (t : X.Hom Y) → motive t | false |
Lean.Compiler.LCNF.withPhase | Lean.Compiler.LCNF.CompilerM | {α : Type} → Lean.Compiler.LCNF.Phase → Lean.Compiler.LCNF.CompilerM α → Lean.Compiler.LCNF.CompilerM α | true |
Std.Rxi.Iterator.ctorIdx | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} → Std.Rxi.Iterator α → ℕ | false |
CategoryTheory.TwoSquare.EquivalenceJ.inverse._proof_8 | Mathlib.CategoryTheory.GuitartExact.Basic | ∀ {C₁ : Type u_8} {C₂ : Type u_2} {C₃ : Type u_6} {C₄ : Type u_4} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_3, u_4} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃}
{R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B) {X₂ : C₂}
{X₃ : C₃} (g : R.obj X₂ ⟶ B.obj X₃) {X Y Z : w.CostructuredArrowDownwards g} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.StructuredArrow.mk (CategoryTheory.CostructuredArrow.homMk X.left.hom ⋯)).hom
((w.costructuredArrowRightwards X₃).map
(CategoryTheory.CostructuredArrow.homMk (CategoryTheory.CategoryStruct.comp x x_1).left.right ⋯)) =
(CategoryTheory.StructuredArrow.mk (CategoryTheory.CostructuredArrow.homMk Z.left.hom ⋯)).hom | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_321 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1)) + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1)) <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
Std.Tactic.BVDecide.BVUnOp.eval_reverse | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ}, Std.Tactic.BVDecide.BVUnOp.reverse.eval = BitVec.reverse | true |
Aesop.RuleTacInput._sizeOf_1 | Aesop.RuleTac.Basic | Aesop.RuleTacInput → ℕ | false |
UInt32.toUInt8_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a < 256 → b < 256 → (a % b).toUInt8 = a.toUInt8 % b.toUInt8 | true |
aestronglyMeasurable_derivWithin_Ici | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] (f : ℝ → F) [CompleteSpace F]
(μ : MeasureTheory.Measure ℝ), MeasureTheory.AEStronglyMeasurable (fun x => derivWithin f (Set.Ici x) x) μ | true |
Lean.Widget.GetWidgetSourceParams.mk.sizeOf_spec | Lean.Widget.UserWidget | ∀ (hash : UInt64) (pos : Lean.Lsp.Position), sizeOf { hash := hash, pos := pos } = 1 + sizeOf hash + sizeOf pos | true |
CategoryTheory.ParametrizedAdjunction.liftStructEquiv._proof_8 | Mathlib.CategoryTheory.LiftingProperties.ParametrizedAdjunction | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} (adj₂ : F ⊣₂ G) {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁}
{X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂} {X₃ Y₃ : C₃} {f₃ : X₃ ⟶ Y₃} (sq₁₂ : F.PushoutObjObj f₁ f₂) (sq₁₃ : G.PullbackObjObj f₁ f₃)
(α : CategoryTheory.Arrow.mk sq₁₂.ι ⟶ CategoryTheory.Arrow.mk f₃)
(x : CategoryTheory.Arrow.LiftStruct ((adj₂.arrowHomEquiv sq₁₂ sq₁₃) α)),
(fun l => { l := adj₂.homEquiv l.l, fac_left := ⋯, fac_right := ⋯ })
((fun l => { l := adj₂.homEquiv.symm l.l, fac_left := ⋯, fac_right := ⋯ }) x) =
x | false |
Nat.mem_factoredNumbers_iff_primeFactors_subset | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ}, m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ m.primeFactors ⊆ s | true |
SimplyConnectedSpace.mk._flat_ctor | Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected | ∀ {X : Type u_3} [inst : TopologicalSpace X],
Nonempty (FundamentalGroupoid X ≌ CategoryTheory.Discrete Unit) → SimplyConnectedSpace X | false |
LieAlgebra.SemiDirectSum.toProd._proof_2 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] {ψ : L →ₗ⁅R⁆ LieDerivation R K K} (x : K × L),
({ left := x.1, right := x.2 }.left, { left := x.1, right := x.2 }.right) =
({ left := x.1, right := x.2 }.left, { left := x.1, right := x.2 }.right) | false |
MonCat.Hom.casesOn | Mathlib.Algebra.Category.MonCat.Basic | {A B : MonCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →* ↑B) → motive { hom' := hom' }) → motive t | false |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft_sumInl._proof_1_1 | Mathlib.Logic.Equiv.Basic | ∀ {ι : Type u_4} {ι' : Type u_3} {ι'' : Sort u_2} (π : ι'' → Type u_1) (e : ι ⊕ ι' ≃ ι'')
(f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (i : ι),
(Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inl i)) = f i | false |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_one._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | false |
Subgroup.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G] (s : Subgroup G)
{a b : G}, a ∈ s.topologicalClosure.carrier → b ∈ s.topologicalClosure.carrier → a * b ∈ s.topologicalClosure.carrier | false |
FourierInvSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransformInv E F],
(∀ (r : R) (f : E), FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f) →
FourierInvSMul R E F | false |
_private.Init.Data.String.Basic.0.String.Pos.sliceFrom._proof_1 | Init.Data.String.Basic | ∀ {s : String} (p₀ pos : s.Pos),
p₀ ≤ pos → String.Pos.Raw.IsValidForSlice (s.sliceFrom p₀) (pos.offset.unoffsetBy p₀.offset) | false |
Subfield.topologicalClosure.congr_simp | Mathlib.Topology.Instances.Complex | ∀ {α : Type u_2} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α]
(K K_1 : Subfield α), K = K_1 → K.topologicalClosure = K_1.topologicalClosure | true |
WithLp.neg_snd | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : AddCommGroup β] (x : WithLp p (α × β)),
(-x).snd = -x.snd | true |
MeasureTheory.AEStronglyMeasurable.real_toNNReal | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.AEStronglyMeasurable (fun x => (f x).toNNReal) μ | true |
Descriptive.Tree.drop_coe | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} (T : ↥(Descriptive.tree A)) (n : ℕ) (x : ↥T), ↑(Descriptive.Tree.drop T n x) = List.drop n ↑x | true |
Metric.unitClosedBall.coe_mul | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x y : ↑(Metric.closedBall 0 1)), ↑(x * y) = ↑x * ↑y | true |
Lean.Language.Lean.CommandElaboratingSnapshot.noConfusion | Lean.Language.Lean.Types | {P : Sort u} →
{t t' : Lean.Language.Lean.CommandElaboratingSnapshot} →
t = t' → Lean.Language.Lean.CommandElaboratingSnapshot.noConfusionType P t t' | false |
add_mem_closedBall_add_iff | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {a b : E} {r : ℝ} {c : E},
a + c ∈ Metric.closedBall (b + c) r ↔ a ∈ Metric.closedBall b r | true |
circleAverage_log_norm_sub_const_eq_posLog | Mathlib.Analysis.SpecialFunctions.Integrals.PosLogEqCircleAverage | ∀ {a : ℂ}, Real.circleAverage (fun x => Real.log ‖x - a‖) 0 1 = ‖a‖.posLog | true |
Finset.val_covBy_val._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Finset α}, (s.val ⋖ t.val) = (s ⋖ t) | false |
_private.Mathlib.Dynamics.Ergodic.MeasurePreserving.0.MeasureTheory.MeasurePreserving.iterate.match_1_1 | Mathlib.Dynamics.Ergodic.MeasurePreserving | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Matrix.UnitaryGroup.transpose_inv_eq_map_star | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(U : ↥(Matrix.unitaryGroup n α)), (Matrix.UnitaryGroup.transpose U)⁻¹ = Matrix.UnitaryGroup.map_star U | true |
SSet.Truncated.Edge.CompStruct.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ x₂ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })} →
{e₀₁ : SSet.Truncated.Edge x₀ x₁} →
{e₁₂ : SSet.Truncated.Edge x₁ x₂} →
{e₀₂ : SSet.Truncated.Edge x₀ x₂} →
{motive : e₀₁.CompStruct e₁₂ e₀₂ → Sort u_1} →
((simplex :
X.obj
(Opposite.op
{ obj := SimplexCategory.mk 2, property := SSet.Truncated.Edge.CompStruct._proof_1 })) →
(d₂ :
X.map
(SimplexCategory.Truncated.δ₂ 2 SSet.Truncated.Edge._proof_2
SSet.Truncated.Edge.CompStruct._proof_2).op
simplex =
e₀₁.edge) →
(d₀ :
X.map
(SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_2
SSet.Truncated.Edge.CompStruct._proof_2).op
simplex =
e₁₂.edge) →
(d₁ :
X.map
(SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_2
SSet.Truncated.Edge.CompStruct._proof_2).op
simplex =
e₀₂.edge) →
motive { simplex := simplex, d₂ := d₂, d₀ := d₀, d₁ := d₁ }) →
(t : e₀₁.CompStruct e₁₂ e₀₂) → motive t | false |
Aesop.DisplayRuleName.casesOn | Aesop.Rule.Name | {motive : Aesop.DisplayRuleName → Sort u} →
(t : Aesop.DisplayRuleName) →
((n : Aesop.RuleName) → motive (Aesop.DisplayRuleName.ruleName n)) →
motive Aesop.DisplayRuleName.normSimp → motive Aesop.DisplayRuleName.normUnfold → motive t | false |
IsSelfAdjoint.star_eq | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x → star x = x | true |
AlgebraicGeometry.sigmaOpenCover | Mathlib.AlgebraicGeometry.Limits | {σ : Type v} → (g : σ → AlgebraicGeometry.Scheme) → [inst : Small.{u, v} σ] → (∐ g).OpenCover | true |
Int32.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a ^^^ b = 0) = (a = b) | false |
Lean.Server.LoadedILean.moduleUri | Lean.Server.References | Lean.Server.LoadedILean → Lean.Lsp.DocumentUri | true |
Stream'.inits_eq | Mathlib.Data.Stream.Init | ∀ {α : Type u} (s : Stream' α), s.inits = Stream'.cons [s.head] (Stream'.map (List.cons s.head) s.tail.inits) | true |
CategoryTheory.HasRightDual.noConfusion | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} →
{t : CategoryTheory.HasRightDual X} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{inst'_1 : CategoryTheory.MonoidalCategory C'} →
{X' : C'} →
{t' : CategoryTheory.HasRightDual X'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 → X ≍ X' → t ≍ t' → CategoryTheory.HasRightDual.noConfusionType P t t' | false |
Polynomial.expand_mul | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (f : Polynomial R),
(Polynomial.expand R (p * q)) f = (Polynomial.expand R p) ((Polynomial.expand R q) f) | true |
AsBoolRing | Mathlib.Algebra.Ring.BooleanRing | Type u_4 → Type u_4 | true |
lpSubmodule._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ (𝕜 : Type u_3) {α : Type u_1} (E : α → Type u_2) (p : ENNReal) [inst : (i : α) → NormedAddCommGroup (E i)]
[inst_1 : NormedRing 𝕜] [inst_2 : (i : α) → Module 𝕜 (E i)] [∀ (i : α), IsBoundedSMul 𝕜 (E i)] (c : 𝕜),
∀ f ∈ (lp E p).carrier, c • f ∈ (lp E p).carrier | false |
Nat.instAssociativeHAnd | Init.Data.Nat.Bitwise.Lemmas | Std.Associative fun x1 x2 => x1 &&& x2 | true |
UInt16.reduceToNat._regBuiltin.UInt16.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.356 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.