name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
summable_of_absolute_convergence_real | Mathlib.Analysis.Normed.Ring.InfiniteSum | ∀ {f : ℕ → ℝ}, (∃ r, Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, |f i|) Filter.atTop (nhds r)) → Summable f |
LinearMap.BilinForm.tmul.eq_1 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ {R : Type uR} {A : Type uA} {M₁ : Type uM₁} {M₂ : Type uM₂} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : AddCommMonoid M₂] [inst_4 : Algebra R A] [inst_5 : Module R M₁]
[inst_6 : Module A M₁] [inst_7 : SMulCommClass R A M₁] [inst_8 : IsScalarTower R A M₁] [inst_9 : Module R M₂]
(B₁ : LinearMap.BilinForm A M₁) (B₂ : LinearMap.BilinMap R M₂ R),
B₁.tmul B₂ = (LinearMap.BilinForm.tensorDistrib R A) (B₁ ⊗ₜ[R] B₂) |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{lhs rhs : Lean.Expr} →
{configKey : UInt64} →
{lhs' rhs' : Lean.Expr} →
{configKey' : UInt64} →
{ lhs := lhs, rhs := rhs, configKey := configKey } = { lhs := lhs', rhs := rhs', configKey := configKey' } →
(lhs = lhs' → rhs = rhs' → configKey = configKey' → P) → P |
List.Cursor.tail.congr_simp | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (s s_1 : l.Cursor) (e_s : s = s_1) (h : 0 < s.suffix.length), s.tail h = s_1.tail ⋯ |
CategoryTheory.Functor.isoCopyObj | Mathlib.CategoryTheory.NatIso | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) → (obj : C → D) → (e : (X : C) → F.obj X ≅ obj X) → F ≅ F.copyObj obj e |
Finset.mulETransformLeft_inv | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommGroup α] (e : α) (x : Finset α × Finset α),
Finset.mulETransformLeft e⁻¹ x = (Finset.mulETransformRight e x.swap).swap |
Fin.predAbove_le_predAbove | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} {p q : Fin n}, p ≤ q → ∀ {i j : Fin (n + 1)}, i ≤ j → p.predAbove i ≤ q.predAbove j |
Int.divisorsAntidiag.eq_2 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
(Int.negSucc n).divisorsAntidiag =
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
(n + 1).divisorsAntidiagonal).disjUnion
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
(n + 1).divisorsAntidiagonal)
⋯ |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_40 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax |
Besicovitch.BallPackage.ctorIdx | Mathlib.MeasureTheory.Covering.Besicovitch | {β : Type u_1} → {α : Type u_2} → Besicovitch.BallPackage β α → ℕ |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_17 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_3} {S : Type u_1} {A : Type u_2} [inst : Semifield R] [inst_1 : TopologicalSpace R] [inst_2 : Field S]
[inst_3 : TopologicalSpace S] [inst_4 : NonUnitalRing A] [inst_5 : Algebra R S] [inst_6 : Module R A]
[inst_7 : Module S A] [IsScalarTower S A A] [SMulCommClass S A A] [IsScalarTower R S A] {a : A} {f : C(S, R)},
QuasispectrumRestricts a ⇑f → ∀ x ∈ quasispectrum S a, x ∈ ⇑f ⁻¹' quasispectrum R a |
MeasureTheory.Lp.edist_toLp_zero | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f : α → E) (hf : MeasureTheory.MemLp f p μ),
edist (MeasureTheory.MemLp.toLp f hf) 0 = MeasureTheory.eLpNorm f p μ |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.vars | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | Lean.Meta.Simp.Arith.Nat.ToLinear.State → Array Lean.Expr |
Std.DTreeMap.Internal.Impl.insertMany_eq_foldl_impl | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t₁ : Std.DTreeMap.Internal.Impl α β} (h₁ : t₁.Balanced)
{t₂ : Std.DTreeMap.Internal.Impl α β},
↑(t₁.insertMany t₂ h₁) =
Std.DTreeMap.Internal.Impl.foldl (fun acc k v => Std.DTreeMap.Internal.Impl.insert! k v acc) t₁ t₂ |
_private.Mathlib.Computability.Reduce.0.ManyOneEquiv.trans.match_1_1 | Mathlib.Computability.Reduce | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable γ]
{p : α → Prop} {q : β → Prop} {r : γ → Prop} (motive : ManyOneEquiv p q → ManyOneEquiv q r → Prop)
(x : ManyOneEquiv p q) (x_1 : ManyOneEquiv q r),
(∀ (pq : p ≤₀ q) (qp : q ≤₀ p) (qr : q ≤₀ r) (rq : r ≤₀ q), motive ⋯ ⋯) → motive x x_1 |
LowerSet.instSProd | Mathlib.Order.UpperLower.Prod | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → SProd (LowerSet α) (LowerSet β) (LowerSet (α × β)) |
MeasureTheory.Measure.IsAddLeftInvariant.comap | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] {H : Type u_3} [inst_3 : AddGroup H]
{mH : MeasurableSpace H} [MeasurableAdd H] (μ : MeasureTheory.Measure H) [μ.IsAddLeftInvariant] {f : G →+ H},
MeasurableEmbedding ⇑f → (MeasureTheory.Measure.comap (⇑f) μ).IsAddLeftInvariant |
Matrix.SpecialLinearGroup.instCoeInt | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
{R : Type v} → [inst_2 : CommRing R] → Coe (Matrix.SpecialLinearGroup n ℤ) (Matrix.SpecialLinearGroup n R) |
List.getLast?_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} {n : ℕ}, (List.replicate n a).getLast? = if n = 0 then none else some a |
neg_one_pow_eq_neg_one_iff_odd | Mathlib.Algebra.Ring.Parity | ∀ {R : Type u_4} [inst : Monoid R] [inst_1 : HasDistribNeg R] {n : ℕ}, -1 ≠ 1 → ((-1) ^ n = -1 ↔ Odd n) |
unitsCentralizerEquiv._proof_8 | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (M : Type u_1) [inst : Monoid M] (x : Mˣ) (x_1 x_2 : ↥(MulAction.stabilizer (ConjAct Mˣ) x)),
⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ = ⟨↑(ConjAct.ofConjAct ↑(x_1 * x_2)), ⋯⟩ |
_private.Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic.0.ProfiniteAddGrp.Hom.mk.inj | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {hom' hom'_1 : ↑A.toProfinite.toTop →ₜ+ ↑B.toProfinite.toTop},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 |
PeriodPair.derivWeierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | PeriodPair → ℂ → ℂ |
SMulCon.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {P : Sort u} →
{S : Type u_2} →
{M : Type u_3} →
{inst : SMul S M} →
{t : SMulCon S M} →
{S' : Type u_2} →
{M' : Type u_3} →
{inst' : SMul S' M'} →
{t' : SMulCon S' M'} → S = S' → M = M' → inst ≍ inst' → t ≍ t' → SMulCon.noConfusionType P t t' |
Aesop.Frontend.RuleExpr.elab | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.RuleExpr |
List.Chain.iff | Mathlib.Data.List.Chain | ∀ {α : Type u} {R S : α → α → Prop}, (∀ (a b : α), R a b ↔ S a b) → ∀ {l : List α}, List.IsChain R l ↔ List.IsChain S l |
_private.Init.Data.String.Lemmas.Splits.0.String.Slice.Pos.Splits.le_iff_exists_eq_append._simp_1_3 | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) |
_private.Lean.Meta.FunInfo.0.Lean.Meta.FunInfoEnvCacheKey.c | Lean.Meta.FunInfo | Lean.Meta.FunInfoEnvCacheKey✝ → Lean.Name |
ValuationRing.instLEValueGroup._proof_1 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_1) [inst_1 : Field K] [inst_2 : Algebra A K] (a₁ a₂ b₁ b₂ : K),
(MulAction.orbitRel Aˣ K) a₁ b₁ →
(MulAction.orbitRel Aˣ K) a₂ b₂ → (fun a b => ∃ c, c • b = a) a₁ a₂ = (fun a b => ∃ c, c • b = a) b₁ b₂ |
_private.Mathlib.Data.Int.Interval.0.Int.instLocallyFiniteOrder._proof_14 | Mathlib.Data.Int.Interval | ∀ (a b x : ℤ), a < x ∧ x < b → (x - (a + 1)).toNat < (b - a - 1).toNat ∧ a + 1 + ↑(x - (a + 1)).toNat = x |
TopCommRingCat._sizeOf_inst | Mathlib.Topology.Category.TopCommRingCat | SizeOf TopCommRingCat |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Minimal.0.termAbsR | Mathlib.Analysis.InnerProductSpace.Projection.Minimal | Lean.ParserDescr |
isLocalMax_of_deriv' | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) → IsLocalMax f b |
OrthogonalFamily.independent | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E}, (OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) → iSupIndep V |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileNonFinalExpr._unsafe_rec | Lean.Compiler.IR.SimpleGroundExpr | Lean.IR.VarId → Lean.IR.IRType → Lean.IR.Expr → Lean.IR.FnBody → Lean.IR.M✝ Lean.IR.SimpleGroundExpr |
NonUnitalSubsemiring.mem_prod | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
{s : NonUnitalSubsemiring R} {t : NonUnitalSubsemiring S} {p : R × S}, p ∈ s.prod t ↔ p.1 ∈ s ∧ p.2 ∈ t |
BitVec.not_sub_one_eq_not_add_one | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, ~~~(x - 1#w) = ~~~x + 1#w |
Diffeomorph.coe_toHomeomorph | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_7} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 F G} {M : Type u_9} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M] {N : Type u_11}
[inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} (h : Diffeomorph I J M N n),
⇑h.toHomeomorph = ⇑h |
MeasureTheory.eLpNorm'_mono_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_5} {G : Type u_6} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
0 ≤ q → (∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ ‖g x‖) → MeasureTheory.eLpNorm' f q μ ≤ MeasureTheory.eLpNorm' g q μ |
Filter.eventually_mem_set._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α} {l : Filter α}, (∀ᶠ (x : α) in l, x ∈ s) = (s ∈ l) |
isFullyInvariant_iff_sSup_isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
{m : Submodule R M}, m.IsFullyInvariant ↔ ∃ s ⊆ isotypicComponents R M, m = sSup s |
_private.Mathlib.Geometry.Manifold.VectorBundle.Tangent.0.termTM | Mathlib.Geometry.Manifold.VectorBundle.Tangent | Lean.ParserDescr |
List.alternatingSum_nil | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G], [].alternatingSum = 0 |
Lean.Meta.Grind.mkEqHEqProof | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr |
WithLp._sizeOf_inst | Mathlib.Analysis.Normed.Lp.WithLp | (p : ENNReal) → (V : Type u_1) → [SizeOf V] → SizeOf (WithLp p V) |
continuous_clm_apply | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type w} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace 𝕜]
{X : Type u_1} [inst_6 : TopologicalSpace X] [FiniteDimensional 𝕜 E] {f : X → E →L[𝕜] F},
Continuous f ↔ ∀ (y : E), Continuous fun x => (f x) y |
CategoryTheory.Monoidal.functorCategoryMonoidal._proof_13 | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C D} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C D)) f)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom f |
Std.TreeSet.min!_insert_le_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(cmp (t.insert k).min! k).isLE = true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.inner_eq_norm_mul_iff_div._simp_1_6 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
Std.DTreeMap.Internal.Impl.Const.toListModel_insertManyIfNewUnit!_list | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α] {l : List α}
{t : Std.DTreeMap.Internal.Impl α fun x => Unit},
t.WF →
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)).toListModel.Perm
(Std.Internal.List.insertListIfNewUnit t.toListModel l) |
BitVec.sub_add_comm | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {z x y : BitVec w}, x - y + z = x + z - y |
Lean.Elab.Do.DoElemContKind._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.DoElemContKind |
_private.Mathlib.RingTheory.Coalgebra.Basic.0.Coalgebra.sum_tmul_tmul_eq._simp_1_1 | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (m : M) {α : Type u_22} (s : Finset α)
(n : α → N), ∑ a ∈ s, m ⊗ₜ[R] n a = m ⊗ₜ[R] ∑ a ∈ s, n a |
Array.le_sum_div_length_of_min?_eq_some_nat | Init.Data.Array.Nat | ∀ {x : ℕ} {xs : Array ℕ}, xs.min? = some x → x ≤ xs.sum / xs.size |
ULiftable.recOn | Mathlib.Control.ULiftable | {f : Type u₀ → Type u₁} →
{g : Type v₀ → Type v₁} →
{motive : ULiftable f g → Sort u} →
(t : ULiftable f g) →
((congr : {α : Type u₀} → {β : Type v₀} → α ≃ β → f α ≃ g β) → motive { congr := congr }) → motive t |
Module.End.hasEigenvalue_iff_isRoot_charpoly | Mathlib.LinearAlgebra.Eigenspace.Charpoly | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Free R M] [inst_5 : Module.Finite R M] (f : Module.End R M) (μ : R),
f.HasEigenvalue μ ↔ (LinearMap.charpoly f).IsRoot μ |
_private.Batteries.Tactic.Lint.Simp.0.Batteries.Tactic.Lint.formatLemmas._sparseCasesOn_2 | Batteries.Tactic.Lint.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Lat.Iso.mk._proof_3 | Mathlib.Order.Category.Lat | ∀ {α β : Lat} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.State.mk._flat_ctor | Std.Sync.Channel | {α : Type} →
Std.Queue (IO.Promise Bool) →
Std.Queue (Std.CloseableChannel.Bounded.Consumer✝ α) →
(capacity : ℕ) →
Vector (IO.Ref (Option α)) capacity →
ℕ →
(sendIdx : ℕ) →
sendIdx < capacity → (recvIdx : ℕ) → recvIdx < capacity → Bool → Std.CloseableChannel.Bounded.State✝ α |
groupHomology.shortComplexH0 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → Rep k G → CategoryTheory.ShortComplex (ModuleCat k) |
WithBot.instIsOrderedRing | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [IsOrderedRing α]
[inst_4 : CanonicallyOrderedAdd α] [inst_5 : NoZeroDivisors α] [inst_6 : Nontrivial α], IsOrderedRing (WithBot α) |
Batteries.RBNode.Path.insertNew.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (path : Batteries.RBNode.Path α) (v : α),
path.insertNew v = path.ins (Batteries.RBNode.node Batteries.RBColor.red Batteries.RBNode.nil v Batteries.RBNode.nil) |
Batteries.RBNode.setRed.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1}, Batteries.RBNode.nil.setRed = Batteries.RBNode.nil |
Algebra.TensorProduct.tensorTensorTensorComm_symm | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {R' : Type u_1} {S : Type uS} {T : Type u_2} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD}
[inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A]
[inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst_8 : Algebra R B]
[inst_9 : Semiring C] [inst_10 : Algebra R C] [inst_11 : Algebra S C] [inst_12 : IsScalarTower R S C]
[inst_13 : Semiring D] [inst_14 : Algebra R D] [inst_15 : CommSemiring T] [inst_16 : Algebra R T]
[inst_17 : Algebra T A] [inst_18 : IsScalarTower R T A] [inst_19 : SMulCommClass S T A] [inst_20 : Algebra S T]
[inst_21 : IsScalarTower S T A] [inst_22 : CommSemiring R'] [inst_23 : Algebra R R'] [inst_24 : Algebra R' T]
[inst_25 : Algebra R' A] [inst_26 : Algebra R' B] [inst_27 : IsScalarTower R R' A] [inst_28 : SMulCommClass S R' A]
[inst_29 : SMulCommClass R' S A] [inst_30 : IsScalarTower R' T A] [inst_31 : IsScalarTower R R' B],
(Algebra.TensorProduct.tensorTensorTensorComm R R' S T A B C D).symm =
Algebra.TensorProduct.tensorTensorTensorComm R S R' T A C B D |
UInt8.sub_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, b ≤ a → a - b ≤ a |
RingCat.Colimits.Prequotient.ctorElim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(ctorIdx : ℕ) →
(t : RingCat.Colimits.Prequotient F) →
ctorIdx = t.ctorIdx → RingCat.Colimits.Prequotient.ctorElimType ctorIdx → motive t |
AbsoluteValue.isAbsoluteValue | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R]
(abv : AbsoluteValue R S), IsAbsoluteValue ⇑abv |
Matroid.Indep.rankPos_of_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I.Nonempty → M.RankPos |
MeasureTheory.hausdorffMeasure_smul | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {α : Type u_4}
[inst_3 : SMul α X] [IsIsometricSMul α X] {d : ℝ} (c : α),
(0 ≤ d ∨ Function.Surjective fun x => c • x) →
∀ (s : Set X), (MeasureTheory.Measure.hausdorffMeasure d) (c • s) = (MeasureTheory.Measure.hausdorffMeasure d) s |
Std.TreeMap.minKey!_modify | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{k : α} {f : β → β},
(t.modify k f).isEmpty = false → (t.modify k f).minKey! = if cmp t.minKey! k = Ordering.eq then k else t.minKey! |
Std.Time.PlainDateTime.mk.sizeOf_spec | Std.Time.DateTime.PlainDateTime | ∀ (date : Std.Time.PlainDate) (time : Std.Time.PlainTime),
sizeOf { date := date, time := time } = 1 + sizeOf date + sizeOf time |
Lean.Grind.Ring.intCast_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α], ↑0 = 0 |
Finset.Nonempty.of_smul_left | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {s : Finset α} {t : Finset β},
(s • t).Nonempty → s.Nonempty |
CategoryTheory.AdditiveFunctor.ofLeftExact_map | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasZeroObject C] [inst_5 : CategoryTheory.Limits.HasZeroObject D]
[inst_6 : CategoryTheory.Limits.HasBinaryBiproducts C] {F G : C ⥤ₗ D} (α : F ⟶ G),
((CategoryTheory.AdditiveFunctor.ofLeftExact C D).map α).hom = α.hom |
lt_or_le_of_codirected | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] {r v₁ v₂ : α},
r ≤ v₁ → r ≤ v₂ → v₁ < v₂ ∨ v₂ ≤ v₁ |
Lean.Meta.Sym.Simp.Result.rfl.injEq | Lean.Meta.Sym.Simp.SimpM | ∀ (done done_1 : Bool), (Lean.Meta.Sym.Simp.Result.rfl done = Lean.Meta.Sym.Simp.Result.rfl done_1) = (done = done_1) |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.toClass.match_1.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} (motive : W.Point → Sort u_2)
(h_1 : Unit → motive WeierstrassCurve.Affine.Point.zero)
(h_2 : (x y : F) → (h : W.Nonsingular x y) → motive (WeierstrassCurve.Affine.Point.some h)),
(match WeierstrassCurve.Affine.Point.zero with
| WeierstrassCurve.Affine.Point.zero => h_1 ()
| WeierstrassCurve.Affine.Point.some h => h_2 x y h) =
h_1 () |
Algebra.adjoin_insert_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : Set A) (x : A),
Algebra.adjoin R (insert x ↑(Algebra.adjoin R s)) = Algebra.adjoin R (insert x s) |
Lean.Elab.Term.MVarErrorKind._sizeOf_inst | Lean.Elab.Term.TermElabM | SizeOf Lean.Elab.Term.MVarErrorKind |
GrpCat.limitCone | Mathlib.Algebra.Category.Grp.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J GrpCat) →
[Small.{u, max u v} ↑(F.comp (CategoryTheory.forget GrpCat)).sections] → CategoryTheory.Limits.Cone F |
Batteries.Tactic.getExplicitRelArg?._sunfold | Batteries.Tactic.Trans | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) |
Real.rpow_sum_le_const_mul_sum_rpow_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) {f : ι → ℝ} {p : ℝ},
1 ≤ p → (∀ i ∈ s, 0 ≤ f i) → (∑ i ∈ s, f i) ^ p ≤ ↑s.card ^ (p - 1) * ∑ i ∈ s, f i ^ p |
String.Pos.Raw.byteIdx_add_string | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw} {s : String}, (p + s).byteIdx = p.byteIdx + s.utf8ByteSize |
MonCat.Colimits.colimitIsColimit._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (m : (MonCat.Colimits.colimitCocone F).pt ⟶ s.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp ((MonCat.Colimits.colimitCocone F).ι.app j) m = s.ι.app j) →
m = MonCat.Colimits.descMorphism F s |
instHasColimitsOfShapeUnderOfWithInitial | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
(X : C) [CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.WithInitial J) C],
CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Under X) |
ContMDiffAt.curry_left | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_8}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_9} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_10} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{n : WithTop ℕ∞} {f : M → M' → N} {x : M} {y : M'},
ContMDiffAt (I.prod I') J n (Function.uncurry f) (x, y) → ContMDiffAt I J n (fun x => f x y) x |
LaurentPolynomial.degree_zero | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.degree 0 = ⊥ |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_1.splitter | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATCheckerSound | {n : ℕ} →
(motive : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool → Sort u_1) →
(x : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool) →
((fst : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) →
(checkSuccess : Bool) → motive (fst, checkSuccess)) →
motive x |
PNat.factorMultiset.eq_1 | Mathlib.Data.PNat.Factors | ∀ (n : ℕ+), n.factorMultiset = PrimeMultiset.ofNatList (↑n).primeFactorsList ⋯ |
CategoryTheory.Grothendieck.instCategory._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (f : X.Hom Y), CategoryTheory.Grothendieck.comp X.id f = f |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_eq_zero.match_1_1 | Init.Data.Nat.Lemmas | ∀ (n n_1 : ℕ) (motive : (n_1 + 1) * (n + 1) = 0 → Prop) (a : (n_1 + 1) * (n + 1) = 0), motive a |
Submonoid.map_inf_comap_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Surjective ⇑f → ∀ (S T : Submonoid N), Submonoid.map f (Submonoid.comap f S ⊓ Submonoid.comap f T) = S ⊓ T |
CStarModule.inner_zero_left | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] {x : E}, inner A 0 x = 0 |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getEntry_congr._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getEntry a l h) = Std.Internal.List.getEntry? a l |
Lean.Grind.AC.Seq.collectVars._sunfold | Lean.Meta.Tactic.Grind.AC.VarRename | Lean.Grind.AC.Seq → Lean.Meta.Grind.VarCollector |
Matrix.kroneckerBilinear._proof_3 | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_2} {α : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring α] [inst_2 : Algebra R α],
LinearMapClass (α →ₐ[R] Module.End R α) R α (Module.End R α) |
Int.fmod_eq_emod | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a.fmod b = a % b + if 0 ≤ b ∨ b ∣ a then 0 else b |
_private.Init.Data.String.Basic.0.String.Pos.Raw.offsetOfPosAux._unary._proof_1 | Init.Data.String.Basic | ∀ (s : String) (i : String.Pos.Raw),
¬String.Pos.Raw.atEnd s i = true → s.utf8ByteSize - (String.Pos.Raw.next s i).byteIdx < s.utf8ByteSize - i.byteIdx |
ContinuousLinearEquiv.toLinearEquiv | Mathlib.Topology.Algebra.Module.Equiv | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_2 : RingHomInvPair σ σ'] →
[inst_3 : RingHomInvPair σ' σ] →
{M : Type u_3} →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommMonoid M] →
{M₂ : Type u_4} →
[inst_6 : TopologicalSpace M₂] →
[inst_7 : AddCommMonoid M₂] →
[inst_8 : Module R M] → [inst_9 : Module S M₂] → (M ≃SL[σ] M₂) → M ≃ₛₗ[σ] M₂ |
ProofWidgets.MarkdownDisplay.Props.mk | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.