name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Complex.ofReal_one | Mathlib.Data.Complex.Basic | ↑1 = 1 |
Metric.preimage_mul_left_closedEBall | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [IsIsometricSMul G G] (a b : G) (r : ENNReal),
(fun x => a * x) ⁻¹' Metric.closedEBall b r = Metric.closedEBall (a⁻¹ * b) r |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_6 | Init.Data.BitVec.Bitblast | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p |
Lean.Compiler.LCNF.CompilerM.Context.noConfusionType | Lean.Compiler.LCNF.CompilerM | Sort u → Lean.Compiler.LCNF.CompilerM.Context → Lean.Compiler.LCNF.CompilerM.Context → Sort u |
Multiset.decidableDexistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {m : Multiset α} {p : (a : α) → a ∈ m → Prop}, (∃ x ∈ m.attach, p ↑x ⋯) ↔ ∃ a, ∃ (h : a ∈ m), p a h |
ExteriorAlgebra.ι_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M),
((ExteriorAlgebra.ι R) x = 0) = (x = 0) |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.get?_insertIfNew._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) |
Std.Iterators.HetT.bind._proof_3 | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type u_1 → Type u_4} {α : Type u_3} {β : Type u_2} (x : Std.Iterators.HetT m α) (f : α → Std.Iterators.HetT m β),
Std.Internal.Small { b // ∃ a, x.Property a ∧ (fun a b => (f a).Property b) a b } →
Std.Internal.Small { b // ∃ a, x.Property a ∧ (f a).Property b } |
iSup_himp_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] {a : α} {f : ι → α}, (⨆ x, f x) ⇨ a = ⨅ x, f x ⇨ a |
_private.Mathlib.Algebra.CharP.Pi.0.CharP.pi.match_1 | Mathlib.Algebra.CharP.Pi | ∀ (ι : Type u_1) (motive : Nonempty ι → Prop) (hi : Nonempty ι), (∀ (i : ι), motive ⋯) → motive hi |
Std.IterM.DefaultConsumers.forIn'_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x} {it : Std.IterM m β}
{init : γ} {P : β → Prop} {hP : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b}
(PlausibleForInStep : β → γ → ForInStep γ → Prop)
{f : (b : β) → P b → (c : γ) → n (Subtype (PlausibleForInStep b c))},
Std.IteratorLoop.WellFounded α m PlausibleForInStep →
Std.IterM.DefaultConsumers.forIn' lift γ PlausibleForInStep it init P hP f =
(fun x => lift (Std.Shrink it.Step) γ x it.step) fun s =>
match s.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ => do
let __do_lift ← f out ⋯ init
match __do_lift with
| ⟨ForInStep.yield c, property⟩ => Std.IterM.DefaultConsumers.forIn' lift γ PlausibleForInStep it' c P ⋯ f
| ⟨ForInStep.done c, property⟩ => pure c
| ⟨Std.IterStep.skip it', h⟩ => Std.IterM.DefaultConsumers.forIn' lift γ PlausibleForInStep it' init P ⋯ f
| ⟨Std.IterStep.done, property⟩ => pure init |
_private.Mathlib.Algebra.Order.Module.Field.0.Mathlib.Meta.Positivity.evalSMul._sparseCasesOn_9 | Mathlib.Algebra.Order.Module.Field | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Finset.inf'_sup_distrib_right | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : DistribLattice α] {s : Finset ι} (hs : s.Nonempty) (f : ι → α) (a : α),
s.inf' hs f ⊔ a = s.inf' hs fun i => f i ⊔ a |
Valuation.IsUniformizer.val_lt_one | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] {v : Valuation A Γ}
[hv : v.IsRankOneDiscrete] {π : A}, v.IsUniformizer π → v π < 1 |
OrderMonoidHom.comp_apply | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] (f : β →*o γ) (g : α →*o β) (a : α),
(f.comp g) a = f (g a) |
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
(∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsCofiltered J],
CategoryTheory.Limits.PreservesLimitsOfShape J F) →
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F |
_private.Mathlib.Algebra.Group.Action.Faithful.0.FaithfulSMul.trans._simp_1_1 | Mathlib.Algebra.Group.Action.Faithful | ∀ (R : Type u_4) (A : Type u_5) [inst : MulOneClass A] [inst_1 : SMul R A] [IsScalarTower R A A],
FaithfulSMul R A = Function.Injective fun r => r • 1 |
Lean.Meta.ParamInfo.backDeps | Lean.Meta.Basic | Lean.Meta.ParamInfo → Array ℕ |
OrderType.instNontrivial | Mathlib.Order.Types.Defs | Nontrivial OrderType.{u} |
LinearMap.BilinForm.dualSubmoduleToDual._proof_3 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(B : LinearMap.BilinForm S M) (N : Submodule R M) (x : ↥(B.dualSubmodule N)) (r : R) (m : ↥N),
(algebraMap R S) (B.dualSubmoduleParing x (r • m)) = (algebraMap R S) ((RingHom.id R) r • B.dualSubmoduleParing x m) |
_private.Mathlib.Order.ConditionallyCompleteLattice.Basic.0.MonotoneOn.csInf_eq_of_subset_of_forall_exists_le._simp_1_2 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
CategoryTheory.BasedNatTrans.comp_toNatTrans | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} {F G H : CategoryTheory.BasedFunctor 𝒳 𝒴} (α : CategoryTheory.BasedNatTrans F G)
(β : CategoryTheory.BasedNatTrans G H), (α.comp β).toNatTrans = α.vcomp β.toNatTrans |
Option.getD.eq_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (dflt : α), none.getD dflt = dflt |
Filter.Eventually.choice | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {r : α → β → Prop} {l : Filter α} [l.NeBot],
(∀ᶠ (x : α) in l, ∃ y, r x y) → ∃ f, ∀ᶠ (x : α) in l, r x (f x) |
MulActionHom.instAddZeroClass | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] → [inst_1 : AddZeroClass Y] → [inst_2 : DistribSMul N Y] → AddZeroClass (X →ₑ[σ] Y) |
CategoryTheory.prodFunctorToFunctorProd_obj | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} A] (B : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(C : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B × CategoryTheory.Functor A C),
(CategoryTheory.prodFunctorToFunctorProd A B C).obj F = F.1.prod' F.2 |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_78 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α),
(∀ {n s : ℕ} {h : n < (List.idxsOf x tail s).length}, (List.idxsOf x tail s)[n] = List.idxOfNth x tail n + s) →
∀ {n s : ℕ} {h : n < (List.idxsOf x (head :: tail) s).length},
(List.idxsOf x (head :: tail) s)[n] = List.idxOfNth x (head :: tail) n + s |
MeasureTheory.Lp.simpleFunc.toLp | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | {α : Type u_1} →
{E : Type u_4} →
[inst : MeasurableSpace α] →
[inst_1 : NormedAddCommGroup E] →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
(f : MeasureTheory.SimpleFunc α E) → MeasureTheory.MemLp (⇑f) p μ → ↥(MeasureTheory.Lp.simpleFunc E p μ) |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.State.twist._proof_4 | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (state : Batteries.Random.MersenneTwister.State cfg),
↑state.index < cfg.stateSize |
Lean.PersistentHashMap.Node._sizeOf_2_eq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : SizeOf α] [inst_1 : SizeOf β]
(x : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))),
Lean.PersistentHashMap.Node._sizeOf_2 x = sizeOf x |
List.toFinset_range'_1 | Mathlib.Order.Interval.Finset.Nat | ∀ (a b : ℕ), (List.range' a b).toFinset = Finset.Ico a (a + b) |
HomotopicalAlgebra.fibration_unop_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
{X Y : Cᵒᵖ} (f : X ⟶ Y), HomotopicalAlgebra.Fibration f.unop ↔ HomotopicalAlgebra.Cofibration f |
MeasureTheory.Measure.mkMetric_mono | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X]
{m₁ m₂ : ENNReal → ENNReal},
m₁ ≤ᶠ[nhdsWithin 0 (Set.Ici 0)] m₂ → MeasureTheory.Measure.mkMetric m₁ ≤ MeasureTheory.Measure.mkMetric m₂ |
CategoryTheory.InjectiveResolution.descFOne._proof_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
(J : CategoryTheory.InjectiveResolution Z), CategoryTheory.CategoryStruct.comp (J.ι.f 0) (J.cocomplex.d 0 1) = 0 |
Lean.Grind.CommRing.Poly.combine.go.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ p₂ : Lean.Grind.CommRing.Poly), Lean.Grind.CommRing.Poly.combine.go 0 p₁ p₂ = p₁.concat p₂ |
Batteries.instReprRBColor | Batteries.Data.RBMap.Basic | Repr Batteries.RBColor |
Std.Internal.UV.System.PasswdInfo.casesOn | Std.Internal.UV.System | {motive : Std.Internal.UV.System.PasswdInfo → Sort u} →
(t : Std.Internal.UV.System.PasswdInfo) →
((username : String) →
(uid gid : Option UInt64) →
(shell homedir : Option String) →
motive { username := username, uid := uid, gid := gid, shell := shell, homedir := homedir }) →
motive t |
cfcHom.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p p_1 : A → Prop} (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : MetricSpace R] [inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A]
[inst_6 : Ring A] [inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] {a : A}
(ha : p a), cfcHom ha = cfcHom ⋯ |
ProofWidgets.Penrose.DiagramProps.embeds | ProofWidgets.Component.PenroseDiagram | ProofWidgets.Penrose.DiagramProps → Array (String × ProofWidgets.Html) |
ArithmeticFunction.carmichael_mul | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {a b : ℕ},
a.Coprime b →
ArithmeticFunction.Carmichael (a * b) = (ArithmeticFunction.Carmichael a).lcm (ArithmeticFunction.Carmichael b) |
inv_nonpos' | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a : α},
a⁻¹ ≤ 0 ↔ a ≤ 0 |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Mathlib.Meta.Positivity.evalBesicovitchSatelliteConfigR._sparseCasesOn_1 | Mathlib.MeasureTheory.Covering.Besicovitch | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
InnerProductSpace.Core.inner_self_ne_zero | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[cd : InnerProductSpace.Core 𝕜 F] {x : F}, inner 𝕜 x x ≠ 0 ↔ x ≠ 0 |
CategoryTheory.Grp.instGrpObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.Grp.homMk' { hom := CategoryTheory.GrpObj.inv, isMonHom_hom := ⋯ })
(CategoryTheory.CategoryStruct.id H))
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.toUnit H) CategoryTheory.MonObj.one |
MulRingNorm.mulRingNormEquivAbsoluteValue.congr_simp | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : Nontrivial R],
MulRingNorm.mulRingNormEquivAbsoluteValue = MulRingNorm.mulRingNormEquivAbsoluteValue |
_private.Mathlib.Algebra.Homology.SpectralObject.Basic.0.CategoryTheory.Abelian.SpectralObject._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Basic | 0 ≤ 0 |
IsFractionRing.definition._proof_1._@.Mathlib.RingTheory.Localization.FractionRing.1935392398._hygCtx._hyg.2 | Mathlib.RingTheory.Localization.FractionRing | ∀ (A : Type u_1) [inst : CommRing A] {K : Type u_2} [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [IsDomain A] (z : K),
¬z = 0 → (IsLocalization.sec (nonZeroDivisors A) z).1 ∈ nonZeroDivisors A |
HShiftRight.mk | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → (α → β → γ) → HShiftRight α β γ |
CategoryTheory.Limits.CatCospanTransform.«_aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Categorical_CatCospanTransform___macroRules_CategoryTheory_Limits_CatCospanTransform_termλ__1» | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | Lean.Macro |
LinearPMap.sSup_apply | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c)
{l : E →ₗ.[R] F} (hl : l ∈ c) (x : ↥l.domain), ↑(LinearPMap.sSup c hc) ⟨↑x, ⋯⟩ = ↑l x |
Module.subsingletonEquiv._proof_3 | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ (R : Type u_1) (M : Type u_3) (ι : Type u_2) [inst : Semiring R] (r : R) (x : M), 0 = r • 0 |
AffineBasis.sum_coord_apply_eq_one | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P) [inst_4 : Fintype ι] (q : P), ∑ i, (b.coord i) q = 1 |
CategoryTheory.ObjectProperty.instPretriangulatedFullSubcategory._proof_7 | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryTheory.ObjectProperty C) [inst_6 : P.IsTriangulated] (X : P.FullSubcategory),
P.ι.mapTriangle.obj (CategoryTheory.Pretriangulated.contractibleTriangle X) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles |
Qq.Impl.ExprBackSubstResult.unquoted.injEq | Qq.Macro | ∀ (e e_1 : Lean.Expr), (Qq.Impl.ExprBackSubstResult.unquoted e = Qq.Impl.ExprBackSubstResult.unquoted e_1) = (e = e_1) |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeImpl.go.match_1 | Lean.Meta.Tactic.Grind.Internalize | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(d b : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName d b binderInfo)) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((typeName : Lean.Name) →
(idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) → motive e |
Set.smul_mem_smul_set_iff₀._simp_1 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : GroupWithZero α] [inst_1 : MulAction α β] {a : α},
a ≠ 0 → ∀ (A : Set β) (x : β), (a • x ∈ a • A) = (x ∈ A) |
Subgroup.goursat | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)},
∃ G' H' M N,
∃ (x : M.Normal) (x_1 : N.Normal),
∃ e,
I =
Subgroup.map (G'.subtype.prodMap H'.subtype)
(Subgroup.comap ((QuotientGroup.mk' M).prodMap (QuotientGroup.mk' N)) e.toMonoidHom.graph) |
Std.DTreeMap.Internal.Impl.insertMin! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → (k : α) → β k → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β |
NNNorm.recOn | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
{motive : NNNorm E → Sort u} → (t : NNNorm E) → ((nnnorm : E → NNReal) → motive { nnnorm := nnnorm }) → motive t |
LocallyFinite.comp_injOn | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {ι' : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X} {g : ι' → ι},
LocallyFinite f → Set.InjOn g {i | (f (g i)).Nonempty} → LocallyFinite (f ∘ g) |
Quaternion.ratCast_re | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (q : ℚ), (↑q).re = ↑q |
CategoryTheory.HasCardinalFilteredColimits.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
autoParam
(∀ (J : Type w) [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.IsCardinalFiltered J κ],
CategoryTheory.Limits.HasColimitsOfShape J C)
CategoryTheory.HasCardinalFilteredColimits.hasColimitsOfShape._autoParam →
CategoryTheory.HasCardinalFilteredColimits C κ |
WittVector.instAdd | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [hp : Fact (Nat.Prime p)] → [CommRing R] → Add (WittVector p R) |
mulLECancellable_mul._simp_2 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : CommSemigroup α] [MulLeftMono α] {a b : α},
MulLECancellable (a * b) = (MulLECancellable a ∧ MulLECancellable b) |
Finset.card_le_card_biUnion_add_one | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : DecidableEq α] {s : Finset ι} {f : ι → Finset α},
Function.Injective f → (↑s).PairwiseDisjoint f → s.card ≤ (s.biUnion f).card + 1 |
CategoryTheory.Limits.has_cokernel_pair_of_epi | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f],
CategoryTheory.Limits.HasPushout f f |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.run'.match_1 | Init.Data.List.Sort.Impl | {α : Type u_1} →
(n : ℕ) →
(motive : { l // l.length = (n + 2) / 2 } × { l // l.length = (n + 2 + 1) / 2 } → Sort u_2) →
(x : { l // l.length = (n + 2) / 2 } × { l // l.length = (n + 2 + 1) / 2 }) →
((l : { l // l.length = (n + 2) / 2 }) → (r : { l // l.length = (n + 2 + 1) / 2 }) → motive (l, r)) → motive x |
Mathlib.Tactic.Widget.StringDiagram.mkEqHtml | Mathlib.Tactic.Widget.StringDiagram | ProofWidgets.Html → ProofWidgets.Html → ProofWidgets.Html |
NNReal.agmSequences_zero | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agmSequences y 0 = (NNReal.sqrt (x * y), (x + y) / 2) |
Language.mem_sub | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α) (x : List α), x ∈ l - m ↔ x ∈ l ∧ x ∉ m |
Std.DHashMap.Raw.getKey?_eq_some | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, k ∈ m → m.getKey? k = some k |
iInf_prod' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CompleteLattice α] (f : β → γ → α),
⨅ i, ⨅ j, f i j = ⨅ x, f x.1 x.2 |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_8 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (k : Fin n), ↑k < ↑i - 1 → ¬↑k + 1 < ↑i → ↑k + 1 = ↑k + 1 + 1 |
CFC.sqrt_eq_zero_iff._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax |
SpectrumRestricts.starAlgHom._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : TopologicalSpace S]
[IsTopologicalSemiring S] [inst_4 : Algebra R S], ContinuousConstSMul R S |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.mergeWithGrind.match_4 | Mathlib.Tactic.TacticAnalysis.Declarations | (motive : Array Mathlib.TacticAnalysis.TacticNode → Sort u_1) →
(x : Array Mathlib.TacticAnalysis.TacticNode) →
((preI postI : Mathlib.TacticAnalysis.TacticNode) → motive #[preI, postI]) →
((x : Array Mathlib.TacticAnalysis.TacticNode) → motive x) → motive x |
AlgebraicGeometry.LocallyRingedSpace.instCategory._proof_3 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {W X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
AlgebraicGeometry.LocallyRingedSpace.comp (AlgebraicGeometry.LocallyRingedSpace.comp f g) h =
AlgebraicGeometry.LocallyRingedSpace.comp f (AlgebraicGeometry.LocallyRingedSpace.comp g h) |
ProbabilityTheory.integrable_exp_mul_of_le_of_le | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t a b : ℝ},
MeasureTheory.Integrable (fun ω => Real.exp (a * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp (b * X ω)) μ →
a ≤ t → t ≤ b → MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ |
Mathlib.Tactic.MkIff.Shape.mk._flat_ctor | Mathlib.Tactic.MkIffOfInductiveProp | List Bool → Option ℕ → Mathlib.Tactic.MkIff.Shape |
AddChar.FiniteField.primitiveChar._proof_5 | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ (F : Type u_1) (F' : Type u_2) [inst : Field F] [inst_1 : Finite F] [inst_2 : Field F']
(hp₂ : ¬ringChar F' ∣ ringChar F),
(AddChar.primitiveZModChar ((ringChar F).toPNat ⋯) F' ⋯).char.compAddMonoidHom
(Algebra.trace (ZMod (ringChar F)) F).toAddMonoidHom ≠
1 |
PMF.bind_const | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} (p : PMF α) (q : PMF β), (p.bind fun x => q) = q |
PrimeSpectrum.isClosedMap_comap_of_isIntegral | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S),
f.IsIntegral → IsClosedMap (PrimeSpectrum.comap f) |
UniformFun.uniformCore.match_5 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (α : Type u_1) (β : Type u_2) (W : Set (β × β)) (x : UniformFun α β × UniformFun α β)
(motive : x ∈ SetRel.comp (UniformFun.gen α β W) (UniformFun.gen α β W) → Prop)
(x_1 : x ∈ SetRel.comp (UniformFun.gen α β W) (UniformFun.gen α β W)),
(∀ (w : UniformFun α β) (huw : (x.1, w) ∈ UniformFun.gen α β W) (hwv : (w, x.2) ∈ UniformFun.gen α β W), motive ⋯) →
motive x_1 |
Filter.Germ.instAddSemigroup.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : AddSemigroup M],
Filter.Germ.instAddSemigroup = { toAdd := Filter.Germ.instAdd, add_assoc := ⋯ } |
ArithmeticFunction.coe_mk | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Zero R] (f : ℕ → R) (hf : f 0 = 0), ⇑{ toFun := f, map_zero' := hf } = f |
CategoryTheory.CoreSmallCategoryOfSet.mk.sizeOf_spec | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : SizeOf Ω] [inst_2 : SizeOf C]
(obj : Set Ω) (hom : ↑obj → ↑obj → Set Ω) (objEquiv : ↑obj ≃ C)
(homEquiv : {X Y : ↑obj} → ↑(hom X Y) ≃ (objEquiv X ⟶ objEquiv Y)),
sizeOf { obj := obj, hom := hom, objEquiv := objEquiv, homEquiv := homEquiv } = 1 + sizeOf objEquiv |
univ_eq_singleton_of_card_one | Mathlib.Data.Fintype.Card | ∀ {α : Type u_4} [inst : Fintype α] (x : α), Fintype.card α = 1 → Finset.univ = {x} |
GenContFract.Pair.rec | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} →
{motive : GenContFract.Pair α → Sort u} →
((a b : α) → motive { a := a, b := b }) → (t : GenContFract.Pair α) → motive t |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.inner_normalize_ortho | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
inner ℝ y (NormedSpace.normalize (InnerProductGeometry.ortho✝ y x)) = 0 |
_private.Mathlib.RingTheory.SimpleModule.WedderburnArtin.0.isSimpleRing_isArtinianRing_iff._simp_1_6 | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ {R : Type u_5} [inst : Semiring R] {I : Ideal R}, Submodule.IsFullyInvariant I = I.IsTwoSided |
Polynomial.ofSubring | Mathlib.RingTheory.Polynomial.Subring | {R : Type u_1} → [inst : Ring R] → (T : Subring R) → Polynomial ↥T → Polynomial R |
FirstOrder.Language.DirectLimit.exists_quotient_mk'_sigma_mk'_eq | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] (G : ι → Type w) [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {α : Type u_1} [Finite α]
(x : α → FirstOrder.Language.DirectLimit G f), ∃ i y, x = fun a => ⟦FirstOrder.Language.Structure.Sigma.mk f i (y a)⟧ |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_735 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w [g (g a)] [g (g a)].length + 1 ≤ (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w [g (g a)] [g (g a)].length < (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.CodeDecl.fvarId.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1) →
(x : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.CodeDecl.fun decl h)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.jp decl)) →
((fvarId : Lean.FVarId) →
(i : ℕ) →
(y : Lean.FVarId) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.CodeDecl._auto_3) →
motive (Lean.Compiler.LCNF.CodeDecl.uset fvarId i y h)) →
((fvarId : Lean.FVarId) →
(i offset : ℕ) →
(y : Lean.FVarId) →
(ty : Lean.Expr) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.CodeDecl._auto_5) →
motive (Lean.Compiler.LCNF.CodeDecl.sset fvarId i offset y ty h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.CodeDecl._auto_7) →
motive (Lean.Compiler.LCNF.CodeDecl.inc fvarId n check persistent h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.CodeDecl._auto_9) →
motive (Lean.Compiler.LCNF.CodeDecl.dec fvarId n check persistent h)) →
motive x |
MulSemiringAction.noConfusionType | Mathlib.Algebra.Ring.Action.Basic | Sort u_1 →
{M : Type u} →
{R : Type v} →
[inst : Monoid M] →
[inst_1 : Semiring R] →
MulSemiringAction M R →
{M' : Type u} →
{R' : Type v} → [inst' : Monoid M'] → [inst'_1 : Semiring R'] → MulSemiringAction M' R' → Sort u_1 |
HasSum.hasSum_compl_iff | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α] [IsTopologicalAddGroup α]
{f : β → α} {a₁ a₂ : α} {s : Set β}, HasSum (f ∘ Subtype.val) a₁ → (HasSum (f ∘ Subtype.val) a₂ ↔ HasSum f (a₁ + a₂)) |
SeparableClosure.hasEnoughRootsOfUnity_pow | Mathlib.RingTheory.RootsOfUnity.AlgebraicallyClosed | ∀ (F : Type u_1) [inst : Field F] (n k : ℕ) [NeZero ↑n], HasEnoughRootsOfUnity (SeparableClosure F) (n ^ k) |
HasFibers.ι | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳} →
{p : CategoryTheory.Functor 𝒳 𝒮} → [self : HasFibers p] → (S : 𝒮) → CategoryTheory.Functor (HasFibers.Fib p S) 𝒳 |
CategoryTheory.Abelian.SpectralObject.instEpiGShortComplexOpcyclesThreeδ₂Toδ₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (f₂₃ : i₁ ⟶ i₃) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂)
(h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃) (n₀ n₁ n₂ : ℤ) (hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = n₂),
CategoryTheory.Epi (X.shortComplexOpcyclesThreeδ₂Toδ₁ f₁ f₂ f₃ f₁₂ f₂₃ h₁₂ h₂₃ n₀ n₁ n₂ hn₁ hn₂).g |
MonoidWithZeroHom.fst.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.fst G₀ H₀ = WithZero.lift' ((Units.coeHom G₀).comp (MonoidHom.fst G₀ˣ H₀ˣ)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.