name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimpleGraph.isAcyclic_sup_fromEdgeSet_iff | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
(G ⊔ SimpleGraph.edge u v).IsAcyclic ↔ G.IsAcyclic ∧ (G.Reachable u v → u = v ∨ G.Adj u v) | Adding an edge results in an acyclic graph iff the original graph was acyclic and
the edge connects vertices that previously had no path between them. | true |
_private.Mathlib.Order.LiminfLimsup.0.CompleteLatticeHom.apply_limsup_iterate._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ (n m : ℕ), (n + m).succ = n + m.succ | null | false |
sigmaFinsuppAddEquivDFinsupp._proof_2 | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_3} {η : ι → Type u_2} {N : Type u_1} [inst : AddZeroClass N],
Function.RightInverse sigmaFinsuppEquivDFinsupp.invFun sigmaFinsuppEquivDFinsupp.toFun | null | false |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.cast_neg.match_1_1 | Mathlib.Tactic.Ring.Basic | ∀ {n : ℕ} {R : Type u_1} [inst : Ring R] {a : R} (motive : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n) → Prop)
(x : Mathlib.Meta.NormNum.IsInt a (Int.negOfNat n)), (∀ (e : a = ↑(Int.negOfNat n)), motive ⋯) → motive x | null | false |
_private.Mathlib.Analysis.Calculus.VectorField.0.VectorField.lieBracketWithin_add_left._abel_1_2 | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {V W V₁ : E → E} {s : Set E} {x : E},
(fderivWithin 𝕜 W s x) (V x) + (fderivWithin 𝕜 W s x) (V₁ x) -
((fderivWithin 𝕜 V s x) (W x) + (fderivWithin 𝕜 V₁ s x) (W x)) =
(fderiv... | null | false |
IsUniformAddGroup.isLeftUniformAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (α : Type u_1) [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsLeftUniformAddGroup α | null | true |
_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 | null | false |
Lean.Elab.Do.DoElemContKind._sizeOf_inst | Lean.Elab.Do.Basic | SizeOf Lean.Elab.Do.DoElemContKind | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_6 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
2 ≤ List.count w [a, g a, g (g a)] → 1 < (List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length | null | false |
Action.inv_hom_hom_assoc | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] {M N : Action V G}
(f : M ≅ N) {Z : V} (h : N.V ⟶ Z),
CategoryTheory.CategoryStruct.comp f.inv.hom (CategoryTheory.CategoryStruct.comp f.hom.hom h) = h | null | true |
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 | null | true |
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 | null | false |
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 μ | The roots of the characteristic polynomial are exactly the eigenvalues.
`R` is required to be an integral domain, otherwise there is the counterexample:
R = M = Z/6Z, f(x) = 2x, v = 3, μ = 4, but p = X - 2.
| true |
_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 | null | false |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0._aux_Mathlib_Analysis_Complex_PhragmenLindelof___macroRules__private_Mathlib_Analysis_Complex_PhragmenLindelof_0_termExpR_1 | Mathlib.Analysis.Complex.PhragmenLindelof | Lean.Macro | null | false |
instCommRingCorner._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (a b : idem.Corner), a * b = b * a | null | false |
Lat.Iso.mk._proof_3 | Mathlib.Order.Category.Lat | ∀ {α β : Lat} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b | null | false |
_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.Bound... | null | false |
groupHomology.shortComplexH0 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → CategoryTheory.ShortComplex (ModuleCat k) | The (exact) short complex `(G →₀ A) ⟶ A ⟶ A.ρ.coinvariants`. | true |
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 α) | null | true |
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... | null | true |
Complex.cpow_two | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 2 = x ^ 2 | null | true |
UInt8.sub_le | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, b ≤ a → a - b ≤ a | null | true |
Lean.Elab.Tactic.ElabSimpArgsResult.mk.inj | Lean.Elab.Tactic.Simp | ∀ {ctx : Lean.Meta.Simp.Context} {simprocs : Lean.Meta.Simp.SimprocsArray}
{simpArgs : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)} {ctx_1 : Lean.Meta.Simp.Context}
{simprocs_1 : Lean.Meta.Simp.SimprocsArray} {simpArgs_1 : Array (Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult)},
{ ctx := ctx, simpr... | null | true |
Lean.Core.numBinders | Lean.Meta.ExprLens | {M : Type → Type} → [Monad M] → [Lean.MonadError M] → Lean.SubExpr.Pos → Lean.Expr → M ℕ | Returns the number of binders above a given subexpr position. | true |
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 ... | null | false |
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 | A bundled absolute value is an absolute value. | true |
Matroid.Indep.rankPos_of_nonempty | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → I.Nonempty → M.RankPos | null | true |
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.hausdo... | null | true |
MeromorphicAt.update | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : DecidableEq 𝕜] {f : 𝕜 → E} {z : 𝕜},
MeromorphicAt f z → ∀ (w : 𝕜) (e : E), MeromorphicAt (Function.update f w e) z | null | true |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_const_last_eq_one._simp_1_6 | Mathlib.Analysis.Real.OfDigits | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
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! | null | true |
CategoryTheory.Limits.inl_inl_pushoutAssoc_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ Z₁ Z₂ : C} (g₁ : Z₁ ⟶ X₁) (g₂ : Z₁ ⟶ X₂)
(g₃ : Z₂ ⟶ X₂) (g₄ : Z₂ ⟶ X₃) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂]
[inst_2 : CategoryTheory.Limits.HasPushout g₃ g₄]
[inst_3 :
CategoryTheory.Limits.HasPushout (CategoryTheory.CategoryStruc... | null | true |
_private.Lean.Meta.Tactic.Grind.Solve.0.Lean.Meta.Grind.solve._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Solve | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
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 | null | true |
WithBot.isOpenEmbedding_some | Mathlib.Topology.EMetricSpace.Weak | ∀ {α : Type u} [t : TopologicalSpace α] [inst : LinearOrder α] [inst_1 : OrderTopology α],
Topology.IsOpenEmbedding WithBot.some | null | true |
closureCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G],
closureCommutatorRepresentatives G =
Subgroup.closure (Prod.fst '' commutatorRepresentatives G ∪ Prod.snd '' commutatorRepresentatives G) | null | true |
Lean.Grind.Ring.intCast_zero | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α], ↑0 = 0 | null | true |
Std.Async.System.getCurrentUser | Std.Async.System | IO Std.Async.System.SystemUser | Gets the current user by using `passwd`.
On Windows systems, `userId`, `groupId` and `shell` are set to none
| true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_10 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, 0 ≤ w | null | false |
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 | null | true |
IsAddIndecomposable.baseOf_subset_pos | Mathlib.Algebra.Group.Irreducible.Indecomposable | ∀ {ι : Type u_1} {M : Type u_2} {S : Type u_4} [inst : AddMonoid M] [inst_1 : LinearOrder S] [inst_2 : AddMonoid S]
(v : ι → M) (f : M →+ S), IsAddIndecomposable.baseOf v f ⊆ {i | 0 < f (v i)} | null | true |
NormedDivisionRing.nnratCast._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} → (ℕ → α) → (α → α → α) → ℚ≥0 → α | null | false |
Filter.tendsto_ofReal_iff' | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {l : Filter α} {f : α → ℝ} {x : ℝ},
Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) ↔ Filter.Tendsto f l (nhds x) | null | true |
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 : Catego... | **Alias** of `CategoryTheory.AdditiveFunctor.ofLeftExact_map_hom`. | true |
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₁ | null | true |
Ordinal.IsFundamentalSeq | Mathlib.SetTheory.Ordinal.FundamentalSequence | {a o : Ordinal.{u_1}} → (↑(Set.Iio a) → ↑(Set.Iio o)) → Prop | A fundamental sequence for `o` is a strictly monotonic function `Iio o.cof.ord → Iio o` with
cofinal range. We provide `a = o.cof.ord` explicitly to avoid type rewrites. | true |
Lean.Meta.Sym.Simp.Result.rfl.injEq | Lean.Meta.Sym.Simp.SimpM | ∀ (done contextDependent done_1 contextDependent_1 : Bool),
(Lean.Meta.Sym.Simp.Result.rfl done contextDependent = Lean.Meta.Sym.Simp.Result.rfl done_1 contextDependent_1) =
(done = done_1 ∧ contextDependent = contextDependent_1) | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.casesOn | Std.Http.Data.Body.Stream | {motive : Std.Http.Body.Channel.State✝ → Sort u} →
(t : Std.Http.Body.Channel.State✝) →
((pendingProducer : Option Std.Http.Body.Channel.Producer✝) →
(pendingConsumer : Option Std.Http.Body.Channel.Consumer✝) →
(interestWaiter : Option (Std.Async.Waiter Bool)) →
(closed : Bool) →
... | null | false |
_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 x y h)),
(match WeierstrassCurve.Affine.Point.zero with
| Weierstrass... | null | true |
OrderType.lift_type_eq_iff | Mathlib.Order.Types.Defs | ∀ {α β : Type u} [inst : LinearOrder α] [inst_1 : LinearOrder β],
OrderType.lift.{u_1, u} (OrderType.type α) = OrderType.lift.{u_1, u} (OrderType.type β) ↔ Nonempty (α ≃o β) | null | true |
Lean.Order.instMonadTailStateRefT'._aux_1 | Init.Internal.Order.MonadTail | {ω σ : Type} →
{m : Type → Type} →
[inst : Monad m] → [Lean.Order.MonadTail m] → (β : Type) → [Nonempty β] → Lean.Order.CCPO (StateRefT' ω σ m β) | null | false |
Lean.Grind.AC.instBEqSeq.beq._sparseCasesOn_1 | Init.Grind.AC | {motive : Lean.Grind.AC.Seq → Sort u} →
(t : Lean.Grind.AC.Seq) →
((x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Seq.var x)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.ToLevel.ctorIdx | Lean.ToLevel | Lean.ToLevel → ℕ | null | false |
DirichletCharacter.primitiveCharacter_apply_of_isCoprime | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {a : ℤ},
IsCoprime a ↑n → χ.primitiveCharacter ↑a = χ ↑a | null | true |
TopPair.proj₁AdjDiag_unit_app | Mathlib.Topology.Category.TopPair | ∀ (X : TopPair),
TopPair.proj₁AdjDiag.unit.app X = TopPair.ofHom (CategoryTheory.CategoryStruct.id TopPair.fst) TopPair.map ⋯ | null | true |
Lean.Json.«json[_]» | Lean.Data.Json.Elab | Lean.ParserDescr | Json array syntax. | true |
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) | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Util.0.Lean.Elab.Tactic.Do.Internal.VCGen.repeatAndRfl._sparseCasesOn_5 | Lean.Elab.Tactic.Do.Internal.VCGen.Util | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Elab.Term.MVarErrorKind._sizeOf_inst | Lean.Elab.Term.TermElabM | SizeOf Lean.Elab.Term.MVarErrorKind | null | false |
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 | A choice of limit cone for a functor into `GrpCat`.
(Generally, you'll just want to use `limit F`.) | true |
ExceptT.bindCont.match_1 | Init.Control.Except | {ε α : Type u_1} →
(motive : Except ε α → Sort u_2) →
(x : Except ε α) → ((a : α) → motive (Except.ok a)) → ((e : ε) → motive (Except.error e)) → motive x | null | false |
Batteries.Tactic.getExplicitRelArg?._sunfold | Batteries.Tactic.Trans | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | null | false |
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 | For `1 ≤ p`, the `p`-th power of the sum of `f i` is bounded above by a constant times the
sum of the `p`-th powers of `f i`. Version for sums over finite sets, with nonnegative `ℝ`-valued
functions. | true |
AlgebraicGeometry.instSurjectiveOfGeometricallyIntegral | Mathlib.AlgebraicGeometry.Geometrically.Integral | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) [AlgebraicGeometry.GeometricallyIntegral f],
AlgebraicGeometry.Surjective f | null | true |
CategoryTheory.FunctorToTypes.binaryProductEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F G : CategoryTheory.Functor C (Type u_1)) (a : C)
(x : (F ⨯ G).obj a),
(fun z => CategoryTheory.FunctorToTypes.prodMk z.1 z.2)
((fun z =>
(((CategoryTheory.ConcreteCategory.hom ((CategoryTheory.FunctorToTypes.binaryProductIso F G).hom.... | null | false |
AddOpposite.opUniformEquivLeft._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.opEquiv.toFun | null | false |
String.Pos.Raw.byteIdx_add_string | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw} {s : String}, (p + s).byteIdx = p.byteIdx + s.utf8ByteSize | null | true |
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.Coli... | null | false |
Lean.ModuleSetup.mk | Lean.Setup | Lean.Name →
Option Lean.PkgId →
Bool →
Option (Array Lean.Import) →
Lean.NameMap Lean.ImportArtifacts →
Array System.FilePath → Array Lean.Plugin → Lean.LeanOptions → Lean.ModuleSetup | null | true |
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) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Traversal.0.SimpleGraph.Walk.support_getElem_one._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, 1 ≤ p.length → 1 < p.support.length | null | false |
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 : NormedAddComm... | Curried `C^n` functions are `C^n` in the first coordinate. | true |
LaurentPolynomial.degree_zero | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R], LaurentPolynomial.degree 0 = ⊥ | null | true |
_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 | null | true |
PNat.factorMultiset.eq_1 | Mathlib.Data.PNat.Factors | ∀ (n : ℕ+), n.factorMultiset = PrimeMultiset.ofNatList (↑n).primeFactorsList ⋯ | null | true |
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 | null | false |
CategoryTheory.Pseudofunctor.ObjectProperty.map_map_hom | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(P : F.ObjectProperty) [inst_1 : P.IsClosedUnderMapObj] {X Y : B} (f : X ⟶ Y) {X_1 Y_1 : P.Obj X} (f_1 : X_1 ⟶ Y_1),
((P.map f).map f_1).hom = (F.map f).toFunctor.map f_1.hom | null | true |
ContinuousMap.comp.eq_1 | Mathlib.Condensed.TopComparison | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : C(β, γ)) (g : C(α, β)), f.comp g = { toFun := ⇑f ∘ ⇑g, continuous_toFun := ⋯ } | null | true |
_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 | null | false |
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 | null | true |
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 | null | true |
Lean.Parser.parserAliases2infoRef | Lean.Parser.Extension | IO.Ref (Lean.NameMap Lean.Parser.ParserAliasInfo) | null | true |
FirstOrder.Language.Substructure.mem_comap | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
{S : L.Substructure N} {f : L.Hom M N} {x : M}, x ∈ FirstOrder.Language.Substructure.comap f S ↔ f x ∈ S | null | true |
Mathlib.CrossRef.Tag.mk.noConfusion | Mathlib.Tactic.CrossRefAttribute | {P : Sort u} →
{declName : Lean.Name} →
{database : Mathlib.CrossRef.Database} →
{tag comment : String} →
{declName' : Lean.Name} →
{database' : Mathlib.CrossRef.Database} →
{tag' comment' : String} →
{ declName := declName, database := database, tag := tag, comme... | null | false |
CategoryTheory.Presieve.BindStruct.hf | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h), S self.f | null | true |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser.evalStatsReport?.match_4 | Aesop.Frontend.Command | (motive : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1} → Sort u_1) →
(r : DoResultPR Aesop.StatsReport (Option Aesop.StatsReport) PUnit.{1}) →
((a : Aesop.StatsReport) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Option Aesop.StatsReport) → (u : PUnit.{1}) → motive (DoResul... | null | false |
EuclideanGeometry.sin_oangle_right_mul_dist_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {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₃ = ↑(Real.pi / 2) → (EuclideanGeometr... | The sine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
opposite side. | true |
Algebra.Generators.compLocalizationAwayAlgHom_relation_eq_zero | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ι),
(Algebra.Gene... | null | true |
_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 | null | false |
SSet.coskAdj | Mathlib.AlgebraicTopology.SimplicialSet.Basic | (n : ℕ) → SSet.truncation n ⊣ SSet.Truncated.cosk n | The adjunction between n-truncation and the n-coskeleton. | true |
CochainComplex.mappingCone.d_fst_v' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] (i j : ℤ) (hij : i + 1 = j),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone φ).d (i - 1) i)
((↑(Cochai... | null | true |
enorm_ne_zero | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, ‖a‖ₑ ≠ 0 ↔ a ≠ 0 | null | true |
CategoryTheory.AddGrp.Hom.hom_add | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : CategoryTheory.AddGrp C}
[inst_3 : CategoryTheory.IsCommAddMonObj H.X] (f g : G ⟶ H), (f + g).hom = f.hom + g.hom | null | true |
SSet.PtSimplex.MulStruct.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op { len := 0 })} →
{f g fg : X.PtSimplex n x} →
{i : Fin n} →
(map : SSet.stdSimplex.obj { len := n + 1 } ⟶ X) →
autoParam (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) map = g.map)
SSet.... | null | false |
Lean.Grind.AC.Seq.collectVars._sunfold | Lean.Meta.Tactic.Grind.AC.VarRename | Lean.Grind.AC.Seq → Lean.Meta.Grind.VarCollector | null | false |
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 α) | null | false |
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 | null | true |
_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 | null | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushArgsTodo._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | Array Lean.Expr → Lean.Expr → Array Lean.Expr | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.