name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Polynomial.C_smul_derivation_apply | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] (D : Derivation R (Polynomial R) A) (a : R) (f : Polynomial R),
Polynomial.C a • D f = a • D f |
Bialgebra.ofAlgHom._proof_17 | Mathlib.RingTheory.Bialgebra.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(comul : A →ₐ[R] TensorProduct R A A) (counit : A →ₐ[R] R),
(Algebra.TensorProduct.map counit (AlgHom.id R A)).comp comul = ↑(Algebra.TensorProduct.lid R A).symm →
LinearMap.rTensor A ↑counit ∘ₗ ↑comul = (TensorProduct.mk R R A) 1 |
AddValuation.mem_supp_iff | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : LinearOrderedAddCommMonoidWithTop Γ₀] [inst_1 : CommRing R]
(v : AddValuation R Γ₀) (x : R), x ∈ v.supp ↔ v x = ⊤ |
CategoryTheory.pullbackShiftFunctorAdd'_inv_app | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] (X : CategoryTheory.PullbackShift C φ)
(a₁ a₂ a₃ : A) (h : a₁ + a₂ = a₃) (b₁ b₂ b₃ : B) (h₁ : b₁ = φ a₁) (h₂ : b₂ = φ a₂) (h₃ : b₃ = φ a₃),
(CategoryTheory.shiftFunctorAdd' (CategoryTheory.PullbackShift C φ) a₁ a₂ a₃ h).inv.app X =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor (CategoryTheory.PullbackShift C φ) a₂).map
((CategoryTheory.pullbackShiftIso C φ a₁ b₁ h₁).hom.app X))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.pullbackShiftIso C φ a₂ b₂ h₂).hom.app ((CategoryTheory.shiftFunctor C b₁).obj X))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X)
((CategoryTheory.pullbackShiftIso C φ a₃ b₃ h₃).inv.app X))) |
AlgebraicTopology.inclusionOfMooreComplexMap_f | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} A] [inst_1 : CategoryTheory.Abelian A]
(X : CategoryTheory.SimplicialObject A) (n : ℕ),
(AlgebraicTopology.inclusionOfMooreComplexMap X).f n = (AlgebraicTopology.NormalizedMooreComplex.objX X n).arrow |
instFromJsonShowMessageParams.fromJson | Lean.Data.Lsp.Window | Lean.Json → Except String ShowMessageParams |
Lean.IR.MaxIndex.State.ctorIdx | Lean.Compiler.IR.FreeVars | Lean.IR.MaxIndex.State → ℕ |
Std.TreeSet.size_insertMany_list | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List α},
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
(∀ a ∈ t, l.contains a = false) → (t.insertMany l).size = t.size + l.length |
Lean.IRPhases.comptime.elim | Lean.Environment | {motive : Lean.IRPhases → Sort u} → (t : Lean.IRPhases) → t.ctorIdx = 1 → motive Lean.IRPhases.comptime → motive t |
Polynomial.integralNormalization_eval₂_eq_zero_of_commute | Mathlib.RingTheory.Polynomial.IntegralNormalization | ∀ {R : Type u} [inst : Semiring R] {A : Type u_1} [inst_1 : Semiring A] {p : Polynomial R} (f : R →+* A) {z : A},
Polynomial.eval₂ f z p = 0 →
Commute (f p.leadingCoeff) z →
(∀ {r r' : R}, Commute (f r) (f r')) →
(∀ (x : R), f x = 0 → x = 0) → Polynomial.eval₂ f (f p.leadingCoeff * z) p.integralNormalization = 0 |
Lean.Grind.Ring.OfSemiring.npow._sunfold | Init.Grind.Ring.Envelope | {α : Type u} → [inst : Lean.Grind.Semiring α] → Lean.Grind.Ring.OfSemiring.Q α → ℕ → Lean.Grind.Ring.OfSemiring.Q α |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___unexpand_CategoryTheory_CategoryStruct_id_1 | Mathlib.CategoryTheory.Category.Basic | Lean.PrettyPrinter.Unexpander |
Vector.back_ofFn._proof_2 | Init.Data.Vector.OfFn | ∀ {n : ℕ} [NeZero n], n - 1 < n |
ChainCompletePartialOrder.IsAdmissible | Mathlib.Order.BourbakiWitt | {α : Type u_1} → [ChainCompletePartialOrder α] → α → (α → α) → Set α → Prop |
QuasispectrumRestricts | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | {R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : NonUnitalRing A] → [Module R A] → [Module S A] → [Algebra R S] → A → (S → R) → Prop |
Lean.pp.mvars.levels | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool |
_private.Mathlib.Analysis.MellinTransform.0.mellin_cpow_smul._simp_1_1 | Mathlib.Analysis.MellinTransform | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a + c - b = a - b + c |
_private.Mathlib.Topology.Order.LeftRight.0.continuousAt_iff_continuous_left_right._simp_1_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
(Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) = Filter.Tendsto f (x₁ ⊔ x₂) y |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.mk | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →
{data : F.OneHypercoverDenseData J₀ J X} →
{X₀ : C₀} →
{f : F.obj X₀ ⟶ X} →
{Y₀ : C₀} →
{g : Y₀ ⟶ X₀} →
(i₀ : data.I₀) →
(q : F.obj Y₀ ⟶ F.obj (data.X i₀)) →
autoParam
(CategoryTheory.CategoryStruct.comp q (data.f i₀) =
CategoryTheory.CategoryStruct.comp (F.map g) f)
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.fac._autoParam →
data.SieveStruct f g |
EuclideanGeometry.oangle_ne_zero_and_ne_pi_iff_affineIndependent | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 ∧ EuclideanGeometry.oangle p₁ p₂ p₃ ≠ ↑Real.pi ↔
AffineIndependent ℝ ![p₁, p₂, p₃] |
AddGroupNorm.instAdd | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : AddGroup E] → Add (AddGroupNorm E) |
TopologicalAddGroup.IsSES.integral_inducedMeasure | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : AddGroup A] [inst_1 : AddGroup B] [inst_2 : AddGroup C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →+ B} {ψ : B →+ C}
(H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A] [inst_7 : IsTopologicalAddGroup B]
[inst_8 : MeasurableSpace A] [inst_9 : BorelSpace A] (μA : MeasureTheory.Measure A) [hμA : μA.IsAddHaarMeasure]
[inst_10 : IsTopologicalAddGroup C] [inst_11 : LocallyCompactSpace B] [inst_12 : MeasurableSpace C]
[inst_13 : BorelSpace C] (μC : MeasureTheory.Measure C) [hμC : μC.IsAddHaarMeasure] [inst_14 : T2Space B]
[inst_15 : MeasurableSpace B] [inst_16 : BorelSpace B] (f : CompactlySupportedContinuousMap B ℝ),
∫ (b : B), f b ∂H.inducedMeasure μA μC = (H.integrate μA μC) f |
powMonoidHom | Mathlib.Algebra.Group.Hom.Basic | {α : Type u_1} → [inst : CommMonoid α] → ℕ → α →* α |
Function.Injective.rightCancelMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : RightCancelMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
(∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n) → RightCancelMonoid M₁ |
AlgebraicGeometry.Scheme.irreducibleComponentIdeal | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | (X : AlgebraicGeometry.Scheme) →
(Z : Set ↥X) → Z ∈ irreducibleComponents ↥X → [AlgebraicGeometry.IsNoetherian X] → X.IdealSheafData |
Aesop.Options'.maxSafePrefixRuleApplications._inherited_default | Aesop.Options.Internal | ℕ |
CategoryTheory.Limits.limitSubobjectProduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.SmallCategory J] →
[inst_2 : CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, u} C] →
(F : CategoryTheory.Functor J C) → CategoryTheory.Limits.limit F ⟶ ∏ᶜ fun j => F.obj j |
OpenPartialHomeomorph.continuousAt | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {x : X}, x ∈ e.source → ContinuousAt (↑e) x |
AffineEquiv.symm._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_4} {P₁ : Type u_3} {P₂ : Type u_1} {V₁ : Type u_5} {V₂ : Type u_2} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂) (p : P₂) (v : V₂),
v +ᵥ p = e.symm.symm (e.linear.symm v +ᵥ e.symm p) |
LinearIsometryEquiv.map_add | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Module R₂ E₂]
(e : E ≃ₛₗᵢ[σ₁₂] E₂) (x y : E), e (x + y) = e x + e y |
CategoryTheory.IsCardinalFiltered.max | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{κ : Cardinal.{w}} →
[hκ : Fact κ.IsRegular] →
[CategoryTheory.IsCardinalFiltered J κ] → {K : Type u'} → (K → J) → HasCardinalLT K κ → J |
MulEquiv.toAdditive._proof_6 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_1} {H : Type u_2} [inst : MulOneClass G] [inst_1 : MulOneClass H] (f : Additive G ≃+ Additive H),
Function.LeftInverse f.invFun f.toFun |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_iff._simp_1_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {lt : LT α} {a b : α}, (a < b) = (b < a) |
FirstOrder.instDecidableEqPresburgerFunc.decEq.match_1 | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | (motive : (a : ℕ) → FirstOrder.presburgerFunc a → FirstOrder.presburgerFunc a → Sort u_1) →
(a : ℕ) →
(x x_1 : FirstOrder.presburgerFunc a) →
(Unit → motive 0 FirstOrder.presburgerFunc.zero FirstOrder.presburgerFunc.zero) →
(Unit → motive 0 FirstOrder.presburgerFunc.zero FirstOrder.presburgerFunc.one) →
(Unit → motive 0 FirstOrder.presburgerFunc.one FirstOrder.presburgerFunc.zero) →
(Unit → motive 0 FirstOrder.presburgerFunc.one FirstOrder.presburgerFunc.one) →
(Unit → motive 2 FirstOrder.presburgerFunc.add FirstOrder.presburgerFunc.add) → motive a x x_1 |
Set.inclusion.congr_simp | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t) (a a_1 : ↑s), a = a_1 → Set.inclusion h a = Set.inclusion h a_1 |
Std.Time.ZonedDateTime.subMilliseconds | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.Millisecond.Offset → Std.Time.ZonedDateTime |
Std.Legacy.Range.mk.noConfusion | Init.Data.Range.Basic | {P : Sort u} →
{start stop step : ℕ} →
{step_pos : 0 < step} →
{start' stop' step' : ℕ} →
{step_pos' : 0 < step'} →
[start:stop:step] = [start':stop':step'] → (start = start' → stop = stop' → step = step' → P) → P |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.assignUnassignedLevelMVars | Lean.Meta.Tactic.Grind.EMatch | Array Lean.LMVarId → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Array (Lean.Expr × Lean.Expr)) |
Rep.instModuleCarrierVModuleCat | Mathlib.RepresentationTheory.Rep | {k G : Type u} → [inst : CommRing k] → [inst_1 : Monoid G] → (V : Rep k G) → Module k ↑V.V |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix.ctorIdx | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {n m : ℕ} → Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m → ℕ |
Int.fract_mul_natCast | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsStrictOrderedRing R] (a : R)
(b : ℕ), ∃ z, Int.fract a * ↑b - Int.fract (a * ↑b) = ↑z |
MeasureTheory.OuterMeasure.ofFunction_apply | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} (m : Set α → ENNReal) (m_empty : m ∅ = 0) (s : Set α),
(MeasureTheory.OuterMeasure.ofFunction m m_empty) s = ⨅ t, ⨅ (_ : s ⊆ Set.iUnion t), ∑' (n : ℕ), m (t n) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_filter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
CoxeterMatrix.mk | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
(M : Matrix B B ℕ) →
autoParam M.IsSymm CoxeterMatrix.isSymm._autoParam →
autoParam (∀ (i : B), M i i = 1) CoxeterMatrix.diagonal._autoParam →
autoParam (∀ (i i' : B), i ≠ i' → M i i' ≠ 1) CoxeterMatrix.off_diagonal._autoParam → CoxeterMatrix B |
ProbabilityTheory.gaussianReal_map_neg | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal},
MeasureTheory.Measure.map (fun x => -x) (ProbabilityTheory.gaussianReal μ v) = ProbabilityTheory.gaussianReal (-μ) v |
Mathlib.Linter.Style.setOption.isSetOption | Mathlib.Tactic.Linter.Style | Lean.Syntax → Bool |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.size_erase._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) |
Nat.instLocallyFiniteOrder._proof_7 | Mathlib.Order.Interval.Finset.Nat | ∀ (a b x : ℕ), x ∈ { val := ↑(List.range' (a + 1) (b - a)), nodup := ⋯ } ↔ a < x ∧ x ≤ b |
_private.Init.Grind.Ordered.Field.0.Lean.Grind.Field.IsOrdered.mul_inv_lt_of_mul_lt | Init.Grind.Ordered.Field | ∀ {R : Type u} [inst : Lean.Grind.Field R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsLinearOrder R] [Lean.Grind.OrderedRing R] {a b c : R}, b < 0 → a * b < c → c * b⁻¹ < a |
Nat.support_factorization | Mathlib.Data.Nat.Factorization.Defs | ∀ (n : ℕ), n.factorization.support = n.primeFactors |
CategoryTheory.Limits.isKernelCompMono._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.KernelFork f} (i : CategoryTheory.Limits.IsLimit c) {Z : C}
(g : Y ⟶ Z) [hg : CategoryTheory.Mono g] {h : X ⟶ Z} (hh : h = CategoryTheory.CategoryStruct.comp f g)
(s : CategoryTheory.Limits.Fork h 0),
CategoryTheory.CategoryStruct.comp
(↑(CategoryTheory.Limits.KernelFork.IsLimit.lift' i (CategoryTheory.Limits.Fork.ofι s.ι ⋯).ι ⋯))
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.Fork.ι c) ⋯)) =
s.ι ∧
∀
{m :
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero ⟶
((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.Fork.ι c) ⋯).pt).obj
CategoryTheory.Limits.WalkingParallelPair.zero},
CategoryTheory.CategoryStruct.comp m
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.Fork.ι c) ⋯)) =
s.ι →
m = ↑(CategoryTheory.Limits.KernelFork.IsLimit.lift' i (CategoryTheory.Limits.Fork.ofι s.ι ⋯).ι ⋯) |
Path.Homotopy.eval_apply | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p₀ p₁ : Path x₀ x₁} (F : p₀.Homotopy p₁) (t a : ↑unitInterval),
(F.eval t) a = (F.curry t) a |
Lean.MonadWithOptions.rec | Lean.Data.Options | {m : Type → Type} →
{motive : Lean.MonadWithOptions m → Sort u} →
((withOptions : {α : Type} → (Lean.Options → Lean.Options) → m α → m α) → motive { withOptions := withOptions }) →
(t : Lean.MonadWithOptions m) → motive t |
Set.indicator_univ | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] (f : α → M), Set.univ.indicator f = f |
_private.Mathlib.Data.List.Cycle.0.Cycle.decidableNontrivialCoe.match_1.splitter | Mathlib.Data.List.Cycle | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) → ((x : α) → motive [x]) → ((x y : α) → (l : List α) → motive (x :: y :: l)) → motive x |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.rpow_logb_eq_abs._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α}, (0 < |a|) = (a ≠ 0) |
Bundle.Trivialization.codExtend_target | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace Z] {s : Set B} (hs : IsOpen s) (nonempty : s.Nonempty) {proj : Z → ↑s}
(e : Bundle.Trivialization F proj),
(Bundle.Trivialization.codExtend hs nonempty e).target = Prod.map Subtype.val id '' e.toPretrivialization.target |
_private.Mathlib.NumberTheory.LucasLehmer.0.Mathlib.Meta.Positivity.evalMersenne._sparseCasesOn_1 | Mathlib.NumberTheory.LucasLehmer | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Cardinal.ord.orderEmbedding._proof_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ (x x_1 : Cardinal.{u_1}), x < x_1 → x.ord < x_1.ord |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpFixedPrefix.go.match_1 | Lean.Meta.Sym.Simp.App | (motive : Lean.Meta.Sym.Simp.Result × Lean.Expr → Sort u_1) →
(__discr : Lean.Meta.Sym.Simp.Result × Lean.Expr) →
((hf : Lean.Meta.Sym.Simp.Result) → (fType : Lean.Expr) → motive (hf, fType)) → motive __discr |
ZMod.exists_one_add_mul_pow_prime_eq | Mathlib.RingTheory.ZMod.UnitsCyclic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R} {p : ℕ},
Nat.Prime p → v ∣ u → ↑p * u * v ∣ u ^ p → ∀ (x : R), ∃ y, (1 + u * x) ^ p = 1 + ↑p * u * (x + v * y) |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A] (a b : Aᵐᵒᵖ), a + b = b + a |
LieSubmodule.iSupIndep_toSubmodule._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {ι : Type u_1} {N : ι → LieSubmodule R L M},
(iSupIndep fun i => ↑(N i)) = iSupIndep N |
Fin.val_add_one_of_lt' | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i : Fin n}, ↑i + 1 < n → ↑(i + 1) = ↑i + 1 |
CochainComplex.truncateAugment_inv_f | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : CochainComplex V ℕ) {X : V} (f : X ⟶ C.X 0) (w : CategoryTheory.CategoryStruct.comp f (C.d 0 1) = 0) (i : ℕ),
(C.truncateAugment f w).inv.f i = CategoryTheory.CategoryStruct.id ((CochainComplex.truncate.obj (C.augment f w)).X i) |
_private.Lean.Meta.Match.MatcherApp.Transform.0.Lean.Meta.MatcherApp.forallAltTelescope' | Lean.Meta.Match.MatcherApp.Transform | {n : Type → Type u_1} →
[Monad n] →
[MonadControlT Lean.MetaM n] →
{α : Type} → Lean.Expr → Lean.Meta.Match.AltParamInfo → (Array Lean.Expr → Array Lean.Expr → n α) → n α |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.typesEqvForBoxing | Lean.Compiler.LCNF.ExplicitBoxing | Lean.Expr → Lean.Expr → Bool |
UniformSpaceCat.extension_comp_hom | Mathlib.Topology.Category.UniformSpace | ∀ {X : UniformSpaceCat} {Y : CpltSepUniformSpace}
(f : (CpltSepUniformSpace.of (UniformSpace.Completion X.carrier)).toUniformSpace ⟶ Y.toUniformSpace),
(UniformSpaceCat.extensionHom (CategoryTheory.CategoryStruct.comp X.completionHom f)).hom = f |
ProbabilityTheory.Kernel.iIndepFun.indepFun_finset₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
{m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (S T : Finset ι),
Disjoint S T →
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), AEMeasurable (f i) (μ.bind ⇑κ)) →
ProbabilityTheory.Kernel.IndepFun (fun a i => f (↑i) a) (fun a i => f (↑i) a) κ μ |
_private.Mathlib.Analysis.Asymptotics.SpecificAsymptotics.0.Asymptotics.isLittleO_pow_pow_cobounded_of_lt._simp_1_1 | Mathlib.Analysis.Asymptotics.SpecificAsymptotics | ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (∀ᶠ (x : α) in f, p x) = ∃ v ∈ f, ∀ y ∈ v, p y |
Aesop.Frontend.Parser.showStats | Aesop.Frontend.Command | Lean.ParserDescr |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.ξ | Mathlib.NumberTheory.NumberField.House | (K : Type u_1) →
[inst : Field K] → [NumberField K] → {β : Type u_3} → (β × (K →+* ℂ) → ℤ) → β → NumberField.RingOfIntegers K |
Measurable.stronglyMeasurable_add | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_5} {E : Type u_6} {x : MeasurableSpace α} [inst : AddCancelMonoid E] [inst_1 : TopologicalSpace E]
[inst_2 : MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [TopologicalSpace.PseudoMetrizableSpace E]
{g f : α → E}, Measurable g → MeasureTheory.StronglyMeasurable f → Measurable (f + g) |
_private.Mathlib.Analysis.Calculus.TangentCone.Basic.0.uniqueDiffWithinAt_closure._simp_1_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ (R : Type u) {E : Type v} [inst : Semiring R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : TopologicalSpace E] (s : Set E) (x : E),
UniqueDiffWithinAt R s x = (Dense ↑(Submodule.span R (tangentConeAt R s x)) ∧ x ∈ closure s) |
Lean.Lsp.InlayHintKind.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort v✝ → Lean.Lsp.InlayHintKind → Lean.Lsp.InlayHintKind → Sort v✝ |
Lean.Parser.Term.dotIdent._regBuiltin.Lean.Parser.Term.dotIdent.declRange_3 | Lean.Parser.Term | IO Unit |
CategoryTheory.Functor.natTransEquiv | Mathlib.CategoryTheory.Functor.FunctorHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
{F G : CategoryTheory.Functor C D} →
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max v' v u))) ⟶
F.functorHom G) ≃
(F ⟶ G) |
Lean.Meta.Grind.Arith.CommRing.Ring.mk.inj | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ {id : ℕ} {type : Lean.Expr} {u : Lean.Level} {ringInst semiringInst : Lean.Expr} {charInst? : Option (Lean.Expr × ℕ)}
{addFn? mulFn? subFn? negFn? powFn? intCastFn? natCastFn? one? : Option Lean.Expr} {vars : Lean.PArray Lean.Expr}
{varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing.Var}
{denote : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.RingExpr} {id_1 : ℕ} {type_1 : Lean.Expr}
{u_1 : Lean.Level} {ringInst_1 semiringInst_1 : Lean.Expr} {charInst?_1 : Option (Lean.Expr × ℕ)}
{addFn?_1 mulFn?_1 subFn?_1 negFn?_1 powFn?_1 intCastFn?_1 natCastFn?_1 one?_1 : Option Lean.Expr}
{vars_1 : Lean.PArray Lean.Expr} {varMap_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing.Var}
{denote_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Arith.CommRing.RingExpr},
{ id := id, type := type, u := u, ringInst := ringInst, semiringInst := semiringInst, charInst? := charInst?,
addFn? := addFn?, mulFn? := mulFn?, subFn? := subFn?, negFn? := negFn?, powFn? := powFn?,
intCastFn? := intCastFn?, natCastFn? := natCastFn?, one? := one?, vars := vars, varMap := varMap,
denote := denote } =
{ id := id_1, type := type_1, u := u_1, ringInst := ringInst_1, semiringInst := semiringInst_1,
charInst? := charInst?_1, addFn? := addFn?_1, mulFn? := mulFn?_1, subFn? := subFn?_1, negFn? := negFn?_1,
powFn? := powFn?_1, intCastFn? := intCastFn?_1, natCastFn? := natCastFn?_1, one? := one?_1, vars := vars_1,
varMap := varMap_1, denote := denote_1 } →
id = id_1 ∧
type = type_1 ∧
u = u_1 ∧
ringInst = ringInst_1 ∧
semiringInst = semiringInst_1 ∧
charInst? = charInst?_1 ∧
addFn? = addFn?_1 ∧
mulFn? = mulFn?_1 ∧
subFn? = subFn?_1 ∧
negFn? = negFn?_1 ∧
powFn? = powFn?_1 ∧
intCastFn? = intCastFn?_1 ∧
natCastFn? = natCastFn?_1 ∧
one? = one?_1 ∧ vars = vars_1 ∧ varMap = varMap_1 ∧ denote = denote_1 |
IsPrimitiveRoot.isUnit_unit | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {ζ : M} {n : ℕ} (hn : n ≠ 0) (hζ : IsPrimitiveRoot ζ n), IsPrimitiveRoot ⋯.unit n |
CategoryTheory.Functor.RightExtension.coneAtFunctor_obj | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (Y : D) (E : L.RightExtension F),
(CategoryTheory.Functor.RightExtension.coneAtFunctor L F Y).obj E = E.coneAt Y |
Ordinal.one_add_natCast | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (m : ℕ), 1 + ↑m = ↑(Order.succ m) |
descPochhammer_eval_eq_prod_range | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ) (r : R),
Polynomial.eval r (descPochhammer R n) = ∏ j ∈ Finset.range n, (r - ↑j) |
Cardinal.nsmul_lt_aleph0_iff_of_ne_zero | Mathlib.SetTheory.Cardinal.Basic | ∀ {n : ℕ} {a : Cardinal.{u_1}}, n ≠ 0 → (n • a < Cardinal.aleph0 ↔ a < Cardinal.aleph0) |
Matroid.restrict_eq_freeOn_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.restrict I = Matroid.freeOn I ↔ M.Indep I |
WithBot.image_coe_Iio | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some '' Set.Iio a = Set.Ioo ⊥ ↑a |
CategoryTheory.Limits.kernelSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectIso f).hom
(CategoryTheory.Limits.kernel.ι f) =
(CategoryTheory.Limits.kernelSubobject f).arrow |
CategoryTheory.GradedObject.Monoidal.braiding_naturality_right | Mathlib.CategoryTheory.GradedObject.Braiding | ∀ {I : Type u_1} [inst : AddCommMonoid I] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.GradedObject I C)
{Y Z : CategoryTheory.GradedObject I C} [inst_3 : CategoryTheory.BraidedCategory C] [inst_4 : X.HasTensor Y]
[inst_5 : Y.HasTensor X] [inst_6 : X.HasTensor Z] [inst_7 : Z.HasTensor X] (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.Monoidal.whiskerLeft X f)
(CategoryTheory.GradedObject.Monoidal.braiding X Z).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.Monoidal.braiding X Y).hom
(CategoryTheory.GradedObject.Monoidal.whiskerRight f X) |
Std.HashMap.Raw.rec | Std.Data.HashMap.Raw | {α : Type u} →
{β : Type v} →
{motive : Std.HashMap.Raw α β → Sort u_1} →
((inner : Std.DHashMap.Raw α fun x => β) → motive { inner := inner }) → (t : Std.HashMap.Raw α β) → motive t |
LieSubmodule.instTop | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → [inst_4 : LieRingModule L M] → Top (LieSubmodule R L M) |
CharTwo.range_intCast | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Ring R] [CharP R 2], Set.range Int.cast = {0, 1} |
SSet.Subcomplex.MulticoequalizerDiagram.isColimit._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.SubcomplexColimits | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type u_2} {U : ι → X.Subcomplex} {V : ι → ι → X.Subcomplex},
A.MulticoequalizerDiagram U V → ∀ (n : SimplexCategoryᵒᵖ) (i j : ι), (V i j).obj n = (U i).obj n ⊓ (U j).obj n |
_private.Init.Data.Iterators.Combinators.Monadic.FlatMap.0.Std.IterM.flattenAfter | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[Std.Iterator α m (Std.IterM m β)] →
[Std.Iterator α₂ m β] → Std.IterM m (Std.IterM m β) → Option (Std.IterM m β) → Std.IterM m β |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_add_one._proof_1_1 | Mathlib.Algebra.Group.Nat.Even | ∀ {n : ℕ}, Even (n + 1) ↔ ¬Even n |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.IneqCnstr.toExprProof.match_7 | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | (motive :
Lean.Meta.Grind.Arith.Linear.ProofM Lean.Expr ×
Lean.Meta.Grind.Arith.Linear.IneqCnstr × Lean.Meta.Grind.Arith.Linear.IneqCnstr →
Sort u_1) →
(x :
Lean.Meta.Grind.Arith.Linear.ProofM Lean.Expr ×
Lean.Meta.Grind.Arith.Linear.IneqCnstr × Lean.Meta.Grind.Arith.Linear.IneqCnstr) →
((pre : Lean.Meta.Grind.Arith.Linear.ProofM Lean.Expr) →
(c₁ c₂ : Lean.Meta.Grind.Arith.Linear.IneqCnstr) → motive (pre, c₁, c₂)) →
motive x |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {V : Type u_1} {G : SimpleGraph V} [inst : DecidableEq V] (x : V) {u v w : V} (p : G.Walk v w),
(Even (List.countP (fun e => decide (x ∈ e)) p.edges) ↔ v ≠ w → x ≠ v ∧ x ≠ w) →
¬decide (x = u ∨ x = v) = true →
(Even (List.countP (fun e => decide (x ∈ e)) p.edges + 0) ↔ ¬u = w → ¬x = u ∧ ¬x = w) |
ProbabilityTheory.variance_linearMap_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (L : ℝ →ₗ[ℝ] ℝ),
ProbabilityTheory.variance (⇑L) (ProbabilityTheory.gaussianReal μ v) = ↑(L 1 ^ 2).toNNReal * ↑v |
Subalgebra.mk.sizeOf_spec | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : SizeOf R]
[inst_4 : SizeOf A] (toSubsemiring : Subsemiring A)
(algebraMap_mem' : ∀ (r : R), (algebraMap R A) r ∈ toSubsemiring.carrier),
sizeOf { toSubsemiring := toSubsemiring, algebraMap_mem' := algebraMap_mem' } = 1 + sizeOf toSubsemiring |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_zero_iff_of_nonneg_ae._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) |
Int.strongRec._proof_2 | Mathlib.Data.Int.Init | ∀ {m : ℤ} (n : ℤ), ¬n < m → n ≥ m |
Mathlib.Meta.Positivity.PositivityExt._sizeOf_1 | Mathlib.Tactic.Positivity.Core | Mathlib.Meta.Positivity.PositivityExt → ℕ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.