name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LinearPMap.domRestrict | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} → [inst_3 : AddCommGroup F] → [inst_4 : Module R F] → (E →ₗ.[R] F) → Submodule R E → E →ₗ.[R] F | true |
MeasureTheory.SimpleFunc.add_lintegral | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f g : MeasureTheory.SimpleFunc α ENNReal),
(f + g).lintegral μ = f.lintegral μ + g.lintegral μ | true |
Std.TreeMap.getElem?_filterMap' | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α}, (Std.TreeMap.filterMap f t)[k]? = t[k]?.bind fun x => f k x | true |
SSet.Truncated.HomotopyCategory.BinaryProduct.functor_comp_inverse | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ (X Y : SSet.Truncated 2),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functor X Y).comp
(SSet.Truncated.HomotopyCategory.BinaryProduct.inverse X Y) =
CategoryTheory.Functor.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).HomotopyCategory | true |
Semiquot.mem_bind | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {β : Type u_2} (q : Semiquot α) (f : α → Semiquot β) (b : β), b ∈ q.bind f ↔ ∃ a ∈ q, b ∈ f a | true |
Rep.norm_comm_apply | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} [inst : CommRing k] {G : Type v} [inst_1 : Group G] [inst_2 : Fintype G] {A B : Rep.{u_1, u, v} k G}
(f : A ⟶ B) (x : ↑A),
B.ρ.norm ((CategoryTheory.ConcreteCategory.hom f) x) = (CategoryTheory.ConcreteCategory.hom f) (A.ρ.norm x) | true |
Frm.ofHom_apply | Mathlib.Order.Category.Frm | ∀ {X Y : Type u} [inst : Order.Frame X] [inst_1 : Order.Frame Y] (f : FrameHom X Y) (x : X),
(CategoryTheory.ConcreteCategory.hom (Frm.ofHom f)) x = f x | true |
Polynomial.abs_div_tendsto_atBot_atTop_of_degree_gt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q.degree < P.degree →
Q ≠ 0 → Filter.Tendsto (fun x => |Polynomial.eval x P / Polynomial.eval x Q|) Filter.atBot Filter.atTop | true |
Bicategory.Opposite.op2_associator | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
(CategoryTheory.Bicategory.associator f g h).op2 = (CategoryTheory.Bicategory.associator h.op g.op f.op).symm | true |
ProbabilityTheory.paretoPDFReal.eq_1 | Mathlib.Probability.Distributions.Pareto | ∀ (t r x : ℝ), ProbabilityTheory.paretoPDFReal t r x = if t ≤ x then r * t ^ r * x ^ (-(r + 1)) else 0 | true |
ModuleCat.smulNatTrans._proof_3 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ (R : Type u_1) [inst : Ring R], { app := fun M => M.smul 0, naturality := ⋯ }.app = CategoryTheory.NatTrans.app 0 | false |
AddSubmonoid.LocalizationMap.map_add_left | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N] {P : Type u_3}
[inst_2 : AddCommMonoid P] (f : S.LocalizationMap N) {g : M →+ P} {T : AddSubmonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : AddCommMonoid Q] {k : T.LocalizationMap Q} (z : N),
k (g ↑(f.sec z).2) + (f.map hy k) z = k (g (f.sec z).1) | true |
Aesop.Frontend.RuleExpr.noConfusionType | Aesop.Frontend.RuleExpr | Sort u → Aesop.Frontend.RuleExpr → Aesop.Frontend.RuleExpr → Sort u | false |
MvPolynomial.instFaithfulSMul | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u_2} {S : Type u_3} {σ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[FaithfulSMul R S], FaithfulSMul (MvPolynomial σ R) (MvPolynomial σ S) | true |
LieIdeal.comap_incl_self | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
LieIdeal.comap I.incl I = ⊤ | true |
instTopologicalSpaceWithConstructibleTopology._proof_3 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set (Set (WithConstructibleTopology X))),
(∀ t ∈ s, TopologicalSpace.GenerateOpen (constructibleTopologySubbasis X) t) →
TopologicalSpace.GenerateOpen (constructibleTopologySubbasis X) (⋃₀ s) | false |
Std.IterM.anyM_pure | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{p : β → ULift.{w, 0} Bool}, Std.IterM.anyM (fun x => pure (p x)) it = Std.IterM.any (fun x => (p x).down) it | true |
NonUnitalAlgHom.lmul._proof_4 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] (x y : A),
(LinearMap.mul R A).toFun (x + y) = (LinearMap.mul R A).toFun x + (LinearMap.mul R A).toFun y | false |
Lean.Elab.WF.GuessLex.instInhabitedBasicMeasure.default | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.BasicMeasure | true |
ULift.nonAssocRing._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_1} [inst : NonAssocRing R], ↑0 = 0 | false |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.exact₂_iff._proof_1_9 | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ComposableArrows C 2),
S.IsComplex →
CategoryTheory.CategoryStruct.comp
(S.map (CategoryTheory.homOfLE CategoryTheory.ComposableArrows.exact₂_iff._proof_1_6✝))
(S.map (CategoryTheory.homOfLE CategoryTheory.ComposableArrows.exact₂_iff._proof_1_8✝)) =
0 | false |
MeasureTheory.lpTrimToLpMeas | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | {α : Type u_1} →
(F : Type u_2) →
(𝕜 : Type u_3) →
(p : ENNReal) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace 𝕜 F] →
{m m0 : MeasurableSpace α} →
(μ : MeasureTheory.Measure α) →
(hm : m ≤ m0) → ↥(MeasureTheory.Lp F p (μ.trim hm)) → ↥(MeasureTheory.lpMeas F 𝕜 m p μ) | true |
Filter.inf_liminf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {u : β → α} [f.NeBot] (a : α),
a ⊓ Filter.liminf u f = Filter.liminf (fun x => a ⊓ u x) f | true |
_private.Mathlib.Order.Filter.Extr.0.IsMinFilter.bicomp_mono.match_1_1 | Mathlib.Order.Filter.Extr | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder β] [inst_1 : Preorder γ] {f : α → β} {a : α} {g : α → γ}
(_x : α) (motive : _x ∈ {x | (fun x => f a ≤ f x) x} ∩ {x | (fun x => g a ≤ g x) x} → Prop)
(x : _x ∈ {x | (fun x => f a ≤ f x) x} ∩ {x | (fun x => g a ≤ g x) x}),
(∀ (hfx : _x ∈ {x | (fun x => f a ≤ f x) x}) (hgx : _x ∈ {x | (fun x => g a ≤ g x) x}), motive ⋯) → motive x | false |
Differentiable.sigmoid | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ},
Differentiable ℝ f → Differentiable ℝ (Real.sigmoid ∘ f) | true |
AddOpposite.instRightCancelSemigroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : RightCancelSemigroup α] (x x_1 : αᵃᵒᵖ), AddOpposite.unop (x * x_1) = AddOpposite.unop (x * x_1) | false |
StarModule.decomposeProdAdjoint_apply | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) (A : Type u_2) [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (i : A),
(StarModule.decomposeProdAdjoint R A) i = ((selfAdjointPart R) i, (skewAdjointPart R) i) | true |
inv_mul_le_iff_le_mul' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c : α}, c⁻¹ * a ≤ b ↔ a ≤ b * c | true |
CategoryTheory.Limits.KernelFork.mapIsLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
{X Y : C} →
{f : X ⟶ Y} →
(c : CategoryTheory.Limits.KernelFork f) →
CategoryTheory.Limits.IsLimit c →
(G : CategoryTheory.Functor C D) →
[inst_4 : G.PreservesZeroMorphisms] →
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.parallelPair f 0) G] →
CategoryTheory.Limits.IsLimit (c.map G) | true |
TensorProduct.lift._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} {R₂ : Type u_5} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] {σ₁₂ : R →+* R₂} {M : Type u_2}
{N : Type u_3} {P₂ : Type u_4} [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂] (f' : M →ₛₗ[σ₁₂] N →ₛₗ[σ₁₂] P₂)
(x y : TensorProduct R M N),
(↑(TensorProduct.liftAux f')).toFun (x + y) =
(↑(TensorProduct.liftAux f')).toFun x + (↑(TensorProduct.liftAux f')).toFun y | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKeyD_modify_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
ContinuousMap.HomotopyWith.coeFn_injective | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop}, Function.Injective DFunLike.coe | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Mathlib.Meta.Positivity.evalGamma._proof_1 | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Real.instZero)), «$_zα» =Q Real.instZero | false |
Set.insert_eq_self._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (insert a s = s) = (a ∈ s) | false |
PNat.natPred.eq_1 | Mathlib.Data.PNat.Basic | ∀ (i : ℕ+), i.natPred = ↑i - 1 | true |
Matrix.swap | Mathlib.LinearAlgebra.Matrix.Swap | (R : Type u_1) → {n : Type u_2} → [Zero R] → [One R] → [DecidableEq n] → n → n → Matrix n n R | true |
String.Pos.cast_lt_cast_iff._simp_1 | Init.Data.String.Basic | ∀ {s t : String} {pos pos' : s.Pos} {h : s = t}, (pos.cast h < pos'.cast h) = (pos < pos') | false |
Lean.Elab.Term.Do.Code.brecOn_5.eq | Lean.Elab.Do.Legacy | ∀ {motive_1 : Lean.Elab.Term.Do.Code → Sort u}
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u}
{motive_5 : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u}
{motive_6 : Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code → Sort u}
{motive_7 : Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code → Sort u}
(t : Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) (F_1 : (t : Lean.Elab.Term.Do.Code) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_1 t → motive_2 t)
(F_3 : (t : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_2 t → motive_3 t)
(F_4 : (t : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_3 t → motive_4 t)
(F_5 : (t : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) → Lean.Elab.Term.Do.Code.below_4 t → motive_5 t)
(F_6 : (t : Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Lean.Elab.Term.Do.Code.below_5 t → motive_6 t)
(F_7 : (t : Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Lean.Elab.Term.Do.Code.below_6 t → motive_7 t),
Lean.Elab.Term.Do.Code.brecOn_5 t F_1 F_2 F_3 F_4 F_5 F_6 F_7 =
F_6 t (Lean.Elab.Term.Do.Code.brecOn_5.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7).2 | true |
Bool.or_eq_false_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = false ↔ x = false ∧ y = false | true |
_private.Mathlib.Data.Nat.Factors.0.Nat.isChain_cons_primeFactorsList.match_1_1 | Mathlib.Data.Nat.Factors | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (k : ℕ), motive k.succ.succ) → motive n | false |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.Basic.0.nullMeasurableSet_region_between_co._simp_1_1 | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
TopCat.GlueData.MkCore.mk.inj | Mathlib.Topology.Gluing | ∀ {J : Type u} {U : J → TopCat} {V : (i : J) → J → TopologicalSpace.Opens ↑(U i)}
{t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i)}
{V_id : ∀ (i : J), V i i = ⊤} {t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id}
{t_inter :
∀ ⦃i j : J⦄ (k : J) (x : ↥(V i j)), ↑x ∈ V i k → ↑((CategoryTheory.ConcreteCategory.hom (t i j)) x) ∈ V j k}
{cocycle :
∀ (i j k : J) (x : ↥(V i j)) (h : ↑x ∈ V i k),
↑((CategoryTheory.ConcreteCategory.hom (t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (t i k)) ⟨↑x, h⟩)}
{J_1 : Type u} {U_1 : J_1 → TopCat} {V_1 : (i : J_1) → J_1 → TopologicalSpace.Opens ↑(U_1 i)}
{t_1 :
(i j : J_1) →
(TopologicalSpace.Opens.toTopCat (U_1 i)).obj (V_1 i j) ⟶ (TopologicalSpace.Opens.toTopCat (U_1 j)).obj (V_1 j i)}
{V_id_1 : ∀ (i : J_1), V_1 i i = ⊤} {t_id_1 : ∀ (i : J_1), ⇑(CategoryTheory.ConcreteCategory.hom (t_1 i i)) = id}
{t_inter_1 :
∀ ⦃i j : J_1⦄ (k : J_1) (x : ↥(V_1 i j)),
↑x ∈ V_1 i k → ↑((CategoryTheory.ConcreteCategory.hom (t_1 i j)) x) ∈ V_1 j k}
{cocycle_1 :
∀ (i j k : J_1) (x : ↥(V_1 i j)) (h : ↑x ∈ V_1 i k),
↑((CategoryTheory.ConcreteCategory.hom (t_1 j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (t_1 i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (t_1 i k)) ⟨↑x, h⟩)},
{ J := J, U := U, V := V, t := t, V_id := V_id, t_id := t_id, t_inter := t_inter, cocycle := cocycle } =
{ J := J_1, U := U_1, V := V_1, t := t_1, V_id := V_id_1, t_id := t_id_1, t_inter := t_inter_1,
cocycle := cocycle_1 } →
J = J_1 ∧ U ≍ U_1 ∧ V ≍ V_1 ∧ t ≍ t_1 | true |
SemiNormedGrp₁.Hom.normNoninc | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp₁} (self : M.Hom N), self.hom'.NormNoninc | true |
LinearEquiv.isIsotypicOfType_iff_type | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} {N : Type u_3} {S : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup S] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R S]
(e : N ≃ₗ[R] S), IsIsotypicOfType R M N ↔ IsIsotypicOfType R M S | true |
Set.Icc.convexCombo_assoc_coeff₁' | Mathlib.Topology.UnitInterval | ↑unitInterval → ↑unitInterval → ↑unitInterval | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{a b toIntThm : Lean.Expr} →
{lhs rhs : Int.Linear.Expr} →
{a' b' toIntThm' : Lean.Expr} →
{lhs' rhs' : Int.Linear.Expr} →
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a b toIntThm lhs rhs =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a' b' toIntThm' lhs' rhs' →
(a = a' → b = b' → toIntThm = toIntThm' → lhs = lhs' → rhs = rhs' → P) → P | false |
Set.image_mul_left_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀},
0 < a → ∀ (b c : G₀), (fun x => a * x) '' Set.Ioo b c = Set.Ioo (a * b) (a * c) | true |
_private.Mathlib.RingTheory.NoetherNormalization.0.NoetherNormalization.hom2._proof_3 | Mathlib.RingTheory.NoetherNormalization | ∀ {k : Type u_1} [inst : Field k] {n : ℕ},
IsScalarTower k (Polynomial (MvPolynomial (Fin n) k)) (Polynomial (MvPolynomial (Fin n) k)) | false |
Except.bind.eq_2 | Init.Control.Lawful.MonadLift.Instances | ∀ {ε : Type u} {α : Type u_1} {β : Type u_2} (f : α → Except ε β) (v : α), (Except.ok v).bind f = f v | true |
Finset.fold_sup_bot_singleton | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), Finset.fold (fun x1 x2 => x1 ⊔ x2) ⊥ singleton s = s | true |
IsUnit.isQuotientMap_nsmul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} [inst : TopologicalSpace α] {M : Type u_4} {β : Type u_5} [inst_1 : Semiring M]
[inst_2 : AddCommMonoid α] [inst_3 : Module M α] [ContinuousConstSMul M α] [inst_5 : AddMonoid β] (f : α →+ β)
[inst_6 : TopologicalSpace β],
Topology.IsQuotientMap ⇑f → ∀ (n : ℕ), IsUnit ↑n → Topology.IsQuotientMap fun x => n • x | true |
Set.Ioi.eq_1 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (b : α), Set.Ioi b = {x | b < x} | true |
LinearPMap.instSubtractionCommMonoid._proof_3 | 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] (a : E →ₗ.[R] F), zsmulRec nsmulRec 0 a = 0 | false |
TensorProduct.assoc._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R (TensorProduct R M N) P) | false |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_le_of_mem_fixedPoints._simp_1_3 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | false |
Int64.ofIntTruncate | Init.Data.SInt.Basic | ℤ → Int64 | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.eq_swap_mul_swap_iff_mem_support._proof_1_5 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} (x : α), [x, g x, g (g x)].Nodup → ¬x = g (g x) | false |
Stream'.WSeq.length.match_3 | Mathlib.Data.WSeq.Defs | {α : Type u_1} →
(motive : ℕ × Stream'.WSeq α → Sort u_2) →
(x : ℕ × Stream'.WSeq α) → ((n : ℕ) → (s : Stream'.WSeq α) → motive (n, s)) → motive x | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withUsed | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.InductiveElabStep2 →
Array Lean.Expr → List Lean.InductiveType → (Array Lean.Expr → Lean.Elab.TermElabM α) → Lean.Elab.TermElabM α | true |
AddAction.IsQuasiPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | (G : Type u_1) → (X : Type u_2) → [inst : AddGroup G] → [AddAction G X] → Prop | true |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.filter_ne_eq_erase._proof_1_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (f : Π₀ (i : ι), β i)
(i : ι), DFinsupp.filter (fun x => ¬x = i) f = DFinsupp.erase i f | false |
CategoryTheory.nerve.δ₁_mk₂_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₀ X₁ X₂ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂),
CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 1 (CategoryTheory.ComposableArrows.mk₂ f g) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategoryStruct.comp f g) | true |
Std.Do.SPred.Tactic.instPropAsSPredTautologyEntailsPureTrue | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs}, Std.Do.SPred.Tactic.PropAsSPredTautology (⊢ₛ P) P | true |
Lean.Parser.Term.hole._regBuiltin.Lean.Parser.Term.hole.parenthesizer_13 | Lean.Parser.Term.Basic | IO Unit | false |
Algebra.IsAlgebraic.algEquivEquivAlgHom.congr_simp | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (L : Type u_2) [inst : CommRing K] [inst_1 : IsDomain K] [inst_2 : Field L] [inst_3 : Algebra K L]
[inst_4 : Module.IsTorsionFree K L] [inst_5 : Algebra.IsAlgebraic K L],
Algebra.IsAlgebraic.algEquivEquivAlgHom K L = Algebra.IsAlgebraic.algEquivEquivAlgHom K L | true |
CategoryTheory.GrothendieckTopology.instHasIsosToPrecoverage | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (J : CategoryTheory.GrothendieckTopology C),
J.toPrecoverage.HasIsos | true |
Lean.SubExpr.Pos.pushNthBindingDomain._unsafe_rec | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos | false |
Std.DHashMap.Raw.inter_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β},
m₁.inter m₂ = m₁ ∩ m₂ | true |
Action.ρAut_apply_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Group G] (A : Action V G)
(g : G), (A.ρAut g).hom = A.ρ g | true |
CategoryTheory.DifferentialObject.Hom | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
CategoryTheory.DifferentialObject S C → CategoryTheory.DifferentialObject S C → Type v | true |
Std.TreeMap.Raw.getKey?_filter_key | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {f : α → Bool}
{k : α}, t.WF → (Std.TreeMap.Raw.filter (fun k x => f k) t).getKey? k = Option.filter f (t.getKey? k) | true |
MeasureTheory.ae_tendsto_ofReal_norm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{F : ℕ → α → β} {f : α → β},
(∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => F n a) Filter.atTop (nhds (f a))) →
∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun n => ENNReal.ofReal ‖F n a‖) Filter.atTop (nhds (ENNReal.ofReal ‖f a‖)) | true |
Mathlib.Meta.FunProp.instToStringTheoremForm | Mathlib.Tactic.FunProp.Theorems | ToString Mathlib.Meta.FunProp.TheoremForm | true |
eq_inv_smul_iff | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_3} {α : Type u_5} [inst : Group G] [inst_1 : MulAction G α] {g : G} {a b : α}, a = g⁻¹ • b ↔ g • a = b | true |
_private.Init.Data.List.MapIdx.0.List.getElem_mapFinIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_2} {β : Type u_1} {as : List α} {f : (i : ℕ) → α → i < as.length → β} {i : ℕ} (head : α) (tail : List α)
{acc : Array β} {h : (head :: tail).length + acc.size = as.length},
¬i < acc.size + 1 → ¬i - acc.size = i - (acc.size + 1) + 1 → False | false |
Quiver.Path.decidableEqBddPathsOfDecidableEq | Mathlib.Combinatorics.Quiver.Path | {V : Type u_1} →
[inst : Quiver V] →
(n : ℕ) →
DecidableEq V →
((v w : V) → DecidableEq (v ⟶ w)) →
((v w : V) → DecidableEq (Quiver.Path.BoundedPaths v w n)) →
(v w : V) → DecidableEq (Quiver.Path.BoundedPaths v w (n + 1)) | true |
AddMonCat.adj._proof_2 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X' X : Type u_1} {Y : AddMonCat} (x : X' ⟶ X) (x_1 : X ⟶ (CategoryTheory.forget AddMonCat).obj Y),
(CategoryTheory.ConcreteCategory.homEquiv.trans FreeAddMonoid.lift.symm).symm
(CategoryTheory.CategoryStruct.comp x x_1) =
CategoryTheory.CategoryStruct.comp (AddMonCat.free.map x)
((CategoryTheory.ConcreteCategory.homEquiv.trans FreeAddMonoid.lift.symm).symm x_1) | false |
meromorphicTrailingCoeffAt | Mathlib.Analysis.Meromorphic.TrailingCoefficient | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} → [inst_1 : NormedAddCommGroup E] → [NormedSpace 𝕜 E] → (𝕜 → E) → 𝕜 → E | true |
Finset.sup'_id_eq_csSup | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {α : Type u_2} [inst : ConditionallyCompleteLattice α] (s : Finset α) (hs : s.Nonempty), s.sup' hs id = sSup ↑s | true |
FormalMultilinearSeries.hasFPowerSeriesOnBall | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace F]
(p : FormalMultilinearSeries 𝕜 E F), 0 < p.radius → HasFPowerSeriesOnBall p.sum p 0 p.radius | true |
Submodule.topEquiv._proof_1 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Function.LeftInverse (fun x => ⟨x, ⋯⟩) fun x => ↑x | false |
_private.Mathlib.Util.AddRelatedDecl.0.Mathlib.Tactic.addRelatedDecl.match_3 | Mathlib.Util.AddRelatedDecl | (motive : Lean.Expr × List Lean.Name → Sort u_1) →
(__discr : Lean.Expr × List Lean.Name) →
((newValue : Lean.Expr) → (newLevels : List Lean.Name) → motive (newValue, newLevels)) → motive __discr | false |
Lean.Meta.Grind.SplitSource.beta.inj | Lean.Meta.Tactic.Grind.Types | ∀ {e e_1 : Lean.Expr}, Lean.Meta.Grind.SplitSource.beta e = Lean.Meta.Grind.SplitSource.beta e_1 → e = e_1 | true |
USize.toBitVec_one | Init.Data.UInt.Lemmas | USize.toBitVec 1 = 1#System.Platform.numBits | true |
MonoidHom.op._proof_4 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (x y : Mᵐᵒᵖ),
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) (x * y) =
(MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) x * (MulOpposite.op ∘ ⇑f ∘ MulOpposite.unop) y | false |
Finset.compl_insert | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {s : Finset α} [inst : Fintype α] [inst_1 : DecidableEq α] {a : α}, (insert a s)ᶜ = sᶜ.erase a | true |
List.eq_of_sum_take_eq | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddLeftCancelMonoid M] {L L' : List M},
L.length = L'.length → (∀ i ≤ L.length, (List.take i L).sum = (List.take i L').sum) → L = L' | true |
MeasureTheory.L1.SimpleFunc.integral_add | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedSpace ℝ E] (f g : ↥(MeasureTheory.Lp.simpleFunc E 1 μ)),
MeasureTheory.L1.SimpleFunc.integral (f + g) =
MeasureTheory.L1.SimpleFunc.integral f + MeasureTheory.L1.SimpleFunc.integral g | true |
BialgHomClass.casesOn | Mathlib.RingTheory.Bialgebra.Hom | {F : Type u_1} →
{R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Semiring B] →
[inst_4 : Algebra R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : CoalgebraStruct R B] →
[inst_7 : FunLike F A B] →
{motive : BialgHomClass F R A B → Sort u} →
(t : BialgHomClass F R A B) →
([toCoalgHomClass : CoalgHomClass F R A B] →
[toMonoidHomClass : MonoidHomClass F A B] → motive ⋯) →
motive t | false |
KaehlerDifferential.kerCotangentToTensor._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_3) [inst : CommRing R] (A : Type u_1) (B : Type u_2) [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra A B],
RingHom.ker (algebraMap A B) • ⊤ ≤ (KaehlerDifferential.kerToTensor R A B).ker | false |
Lean.Server.FileWorker.Query._sizeOf_1 | Lean.Server.CodeActions.UnknownIdentifier | Lean.Server.FileWorker.Query → ℕ | false |
Std.Time.TimeZone.Offset.ofHoursAndMinutes | Std.Time.Zoned.Offset | Std.Time.Hour.Offset → Std.Time.Minute.Offset → Std.Time.TimeZone.Offset | true |
CStarMatrix.transpose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} (M : CStarMatrix m n A) (i : n) (j : m), M.transpose i j = M j i | true |
AlgebraicGeometry.tilde.map._proof_1 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} {M N : ModuleCat ↑R} (f : M ⟶ N) ⦃X Y : (TopologicalSpace.Opens ↥(AlgebraicGeometry.Spec R))ᵒᵖ⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.structurePresheafInModuleCat ↑R ↑M).map f_1)
(ModuleCat.ofHom
(AlgebraicGeometry.StructureSheaf.comapₗ (ModuleCat.Hom.hom f) (Opposite.unop Y) (Opposite.unop Y) ⋯)) =
CategoryTheory.CategoryStruct.comp
(ModuleCat.ofHom
(AlgebraicGeometry.StructureSheaf.comapₗ (ModuleCat.Hom.hom f) (Opposite.unop X) (Opposite.unop X) ⋯))
((AlgebraicGeometry.structurePresheafInModuleCat ↑R ↑N).map f_1) | false |
IsUniformEmbedding.casesOn | Mathlib.Topology.UniformSpace.Defs | {α : Type ua} →
{β : Type ub} →
[inst : UniformSpace α] →
[inst_1 : UniformSpace β] →
{f : α → β} →
{motive : IsUniformEmbedding f → Sort u} →
(t : IsUniformEmbedding f) →
((toIsUniformInducing : IsUniformInducing f) → (injective : Function.Injective f) → motive ⋯) → motive t | false |
CategoryTheory.IsRegularMono.lift | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y W : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.IsRegularMono f] →
(k : W ⟶ Y) →
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.left f) =
CategoryTheory.CategoryStruct.comp k (CategoryTheory.IsRegularMono.right f) →
(W ⟶ X) | true |
Mathlib.Tactic.BicategoryLike.MonadHorizontalComp.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
(Mathlib.Tactic.BicategoryLike.WhiskerRight →
Mathlib.Tactic.BicategoryLike.Atom₁ → m Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(Mathlib.Tactic.BicategoryLike.WhiskerRight →
Mathlib.Tactic.BicategoryLike.HorizontalComp → m Mathlib.Tactic.BicategoryLike.HorizontalComp) →
Mathlib.Tactic.BicategoryLike.MonadHorizontalComp m | false |
LipschitzWith.nnorm_le_mul | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F] {f : E → F} {K : NNReal},
LipschitzWith K f → f 0 = 0 → ∀ (x : E), ‖f x‖₊ ≤ K * ‖x‖₊ | true |
CategoryTheory.InitiallySmall.initial_smallCategory | Mathlib.CategoryTheory.Limits.FinallySmall | ∀ {J : Type u} {inst : CategoryTheory.Category.{v, u} J} [self : CategoryTheory.InitiallySmall J], ∃ S x F, F.Initial | true |
Array.findFinIdx?_eq_pmap_findIdx?._simp_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool} {i : ℕ},
(Array.findIdx? p xs = some i) = ∃ (h : i < xs.size), p xs[i] = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p xs[j] = true | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.