name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
_private.Mathlib.SetTheory.ZFC.Cardinal.0.ZFSet.card_insert._simp_1_1
|
Mathlib.SetTheory.ZFC.Cardinal
|
∀ {x : ZFSet.{u}}, Cardinal.lift.{u + 1, u} x.card = Cardinal.mk ↥x
|
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_add_right_lt
|
Mathlib.Algebra.Order.Group.DenselyOrdered
|
∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LT α] [DenselyOrdered α] [AddLeftStrictMono α] {a b c : α},
a + b < c → ∃ b' > b, a + b' < c
|
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_add_of_sign_pos_sign_neg._proof_1_1
|
Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
|
∀ {θ ψ : Real.Angle}, θ.sign = 1 → ψ.sign = -1 → -Real.pi < θ.toReal + ψ.toReal ∧ θ.toReal + ψ.toReal ≤ Real.pi
|
LightProfinite.instWEqualsLocallyBijectiveCoherentTopology
|
Mathlib.Condensed.Light.Instances
|
∀ (A : Type u') [inst : CategoryTheory.Category.{u, u'} A] [CategoryTheory.Limits.HasLimits A]
[CategoryTheory.Limits.HasColimits A] {FA : A → A → Type v} {CA : A → Type u}
[inst_3 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_4 : CategoryTheory.ConcreteCategory A FA]
[CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget A)]
[CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget A)] [(CategoryTheory.forget A).ReflectsIsomorphisms],
(CategoryTheory.coherentTopology LightProfinite).WEqualsLocallyBijective A
|
ball_add_zero
|
Mathlib.Analysis.Normed.Group.Pointwise
|
∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (s : Set E), Metric.ball 0 δ + s = Metric.thickening δ s
|
Manifold.«term_≫_»
|
Mathlib.Geometry.Manifold.ChartedSpace
|
Lean.TrailingParserDescr
|
Subsemigroup.op_inj._simp_3
|
Mathlib.Algebra.Group.Subsemigroup.MulOpposite
|
∀ {M : Type u_2} [inst : Mul M] {S T : Subsemigroup M}, (S.op = T.op) = (S = T)
|
CategoryTheory.Monoidal.InducingFunctorData._sizeOf_1
|
Mathlib.CategoryTheory.Monoidal.Transport
|
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategoryStruct D} →
{F : CategoryTheory.Functor D C} →
[SizeOf C] → [SizeOf D] → CategoryTheory.Monoidal.InducingFunctorData F → ℕ
|
_private.Mathlib.RingTheory.Idempotents.0.eq_of_isNilpotent_sub_of_isIdempotentElem_of_commute._simp_1_1
|
Mathlib.RingTheory.Idempotents
|
∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c
|
Algebra.TensorProduct.piScalarRight_tmul
|
Mathlib.RingTheory.TensorProduct.Pi
|
∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [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] {ι : Type u_4}
[inst_7 : Fintype ι] [inst_8 : DecidableEq ι] (x : A) (y : ι → R),
(Algebra.TensorProduct.piScalarRight R S A ι) (x ⊗ₜ[R] y) = fun i => y i • x
|
AddSubgroup.nsmul_mem_of_index_ne_zero_of_dvd
|
Mathlib.GroupTheory.Index
|
∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G},
H.index ≠ 0 → ∀ (a : G) {n : ℕ}, (∀ (m : ℕ), 0 < m → m ≤ H.index → m ∣ n) → n • a ∈ H
|
Finpartition.rec
|
Mathlib.Order.Partition.Finpartition
|
{α : Type u_1} →
[inst : Lattice α] →
[inst_1 : OrderBot α] →
{a : α} →
{motive : Finpartition a → Sort u} →
((parts : Finset α) →
(supIndep : parts.SupIndep id) →
(sup_parts : parts.sup id = a) →
(bot_notMem : ⊥ ∉ parts) →
motive { parts := parts, supIndep := supIndep, sup_parts := sup_parts, bot_notMem := bot_notMem }) →
(t : Finpartition a) → motive t
|
Lean.StructureResolutionState.rec
|
Lean.Structure
|
{motive : Lean.StructureResolutionState → Sort u} →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) →
(t : Lean.StructureResolutionState) → motive t
|
NFA.toεNFA
|
Mathlib.Computability.EpsilonNFA
|
{α : Type u} → {σ : Type v} → NFA α σ → εNFA α σ
|
_private.Mathlib.Order.Filter.Lift.0.Filter.HasBasis.lift._simp_1_1
|
Mathlib.Order.Filter.Lift
|
∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩
|
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.measure_limRatioMeas_top._simp_1_3
|
Mathlib.MeasureTheory.Covering.Differentiation
|
∀ {r : NNReal}, (↑r = 0) = (r = 0)
|
SetLike.delabSubtypeSetLike
|
Mathlib.Data.SetLike.Basic
|
Lean.PrettyPrinter.Delaborator.Delab
|
_private.Init.Data.Option.Lemmas.0.Option.pfilter_eq_some_iff._simp_1_2
|
Init.Data.Option.Lemmas
|
∀ {α : Type u_1} {o : Option α} {p : (a : α) → o = some a → Bool},
((o.pfilter p).isSome = true) = ∃ a, ∃ (ha : o = some a), p a ha = true
|
Lean.Meta.CongrArgKind.casesOn
|
Lean.Meta.CongrTheorems
|
{motive : Lean.Meta.CongrArgKind → Sort u} →
(t : Lean.Meta.CongrArgKind) →
motive Lean.Meta.CongrArgKind.fixed →
motive Lean.Meta.CongrArgKind.fixedNoParam →
motive Lean.Meta.CongrArgKind.eq →
motive Lean.Meta.CongrArgKind.cast →
motive Lean.Meta.CongrArgKind.heq → motive Lean.Meta.CongrArgKind.subsingletonInst → motive t
|
TestFunction.instAddCommGroup._proof_13
|
Mathlib.Analysis.Distribution.TestFunction
|
∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (x : TestFunction Ω F n), ⇑(-x) = ⇑(-x)
|
Associates.prod_factors
|
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet
|
∀ {α : Type u_1} [inst : CancelCommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Nontrivial α]
(s : Associates.FactorSet α), s.prod.factors = s
|
CategoryTheory.EffectiveEpiFamily.fac
|
Mathlib.CategoryTheory.EffectiveEpi.Basic
|
∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {B W : C} {α : Type u_2} (X : α → C)
(π : (a : α) → X a ⟶ B) [inst_1 : CategoryTheory.EffectiveEpiFamily X π] (e : (a : α) → X a ⟶ W)
(h :
∀ {Z : C} (a₁ a₂ : α) (g₁ : Z ⟶ X a₁) (g₂ : Z ⟶ X a₂),
CategoryTheory.CategoryStruct.comp g₁ (π a₁) = CategoryTheory.CategoryStruct.comp g₂ (π a₂) →
CategoryTheory.CategoryStruct.comp g₁ (e a₁) = CategoryTheory.CategoryStruct.comp g₂ (e a₂))
(a : α), CategoryTheory.CategoryStruct.comp (π a) (CategoryTheory.EffectiveEpiFamily.desc X π e ⋯) = e a
|
Lean.Widget.RpcEncodablePacket.range._@.Lean.Widget.InteractiveGoal.2553565095._hygCtx._hyg.1
|
Lean.Widget.InteractiveGoal
|
Lean.Widget.RpcEncodablePacket✝ → Lean.Json
|
MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one
|
Mathlib.MeasureTheory.Function.L2Space
|
∀ {α : Type u_1} {𝕜 : Type u_4} [inst : RCLike 𝕜] [inst_1 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
{s t : Set α} (hs : MeasurableSet s) (ht : MeasurableSet t)
(hμs : autoParam (μ s ≠ ⊤) MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one._auto_1)
(hμt : autoParam (μ t ≠ ⊤) MeasureTheory.L2.inner_indicatorConstLp_one_indicatorConstLp_one._auto_3),
inner 𝕜 (MeasureTheory.indicatorConstLp 2 hs hμs 1) (MeasureTheory.indicatorConstLp 2 ht hμt 1) = ↑(μ.real (s ∩ t))
|
Valuation.IsEquiv.uniformContinuous_equivWithVal
|
Mathlib.Topology.Algebra.Valued.WithVal
|
∀ {R : Type u_4} {Γ₀ : Type u_5} {Γ₀' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[inst_2 : LinearOrderedCommGroupWithZero Γ₀'] {v : Valuation R Γ₀} {w : Valuation R Γ₀'},
(∀ (γ : Γ₀'ˣ), ∃ r s, 0 < w r ∧ 0 < w s ∧ w r / w s = ↑γ) →
v.IsEquiv w → UniformContinuous ⇑(WithVal.equivWithVal v w)
|
Fin.succAboveOrderEmb_toEmbedding
|
Mathlib.Order.Fin.Basic
|
∀ {n : ℕ} (p : Fin (n + 1)), p.succAboveOrderEmb.toEmbedding = { toFun := p.succAbove, inj' := ⋯ }
|
tendsto_nhds_unique_dist
|
Mathlib.Topology.MetricSpace.Pseudo.Basic
|
∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {l : Filter β} {x y : α} [l.NeBot],
Filter.Tendsto f l (nhds x) → Filter.Tendsto f l (nhds y) → dist x y = 0
|
Sublattice.instCompleteLattice._proof_7
|
Mathlib.Order.Sublattice
|
∀ {α : Type u_1} [inst : Lattice α] (s : Set (Sublattice α)), ∀ a ∈ s, sInf s ≤ a
|
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.toSubgraph_adj_penultimate._proof_1_1
|
Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph
|
∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (w : G.Walk u v), 0 < w.length → w.length - 1 + 1 = w.length
|
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.go._unary.eq_def
|
Lean.Meta.Tactic.AC.Main
|
∀ (preContext : Lean.Meta.AC.PreContext) (atoms : Array Lean.Expr)
(k : Array (Lean.Expr × Option Lean.Expr) → Lean.MetaM Lean.Expr) (α : Lean.Expr) (u : Lean.Level)
(_x : (_ : ℕ) ×' (_ : Array (Lean.Expr × Option Lean.Expr)) ×' (_ : Array Lean.Expr) ×' Array Lean.Expr),
Lean.Meta.AC.abstractAtoms.go._unary✝ preContext atoms k α u _x =
PSigma.casesOn _x fun i acc =>
PSigma.casesOn acc fun acc vars =>
PSigma.casesOn vars fun vars args =>
if h : i < atoms.size then
Lean.Meta.withLocalDeclD `x α fun v => do
let __do_lift ← Lean.Meta.AC.getInstance `Std.LawfulIdentity #[preContext.op, atoms[i]]
match __do_lift with
| none =>
Lean.Meta.AC.abstractAtoms.go._unary✝¹ preContext atoms k α u
⟨i + 1, ⟨acc.push (v, none), ⟨vars.push v, args.push atoms[i]⟩⟩⟩
| some inst =>
Lean.Meta.withLocalDeclD `inst (Lean.mkApp3 (Lean.mkConst `Std.LawfulIdentity [u]) α preContext.op v)
fun iv =>
Lean.Meta.AC.abstractAtoms.go._unary✝² preContext atoms k α u
⟨i + 1, ⟨acc.push (v, some iv), ⟨vars ++ #[v, iv], args ++ #[atoms[i], inst]⟩⟩⟩
else do
let proof ← k acc
let proof ← Lean.Meta.mkLambdaFVars vars proof
have proof : Lean.Expr := Lean.mkAppN proof args
pure proof
|
Vector.swapAt!_mk._proof_1
|
Init.Data.Vector.Lemmas
|
∀ {α : Type u_1} {n : ℕ} {xs : Array α}, xs.size = n → ∀ {i : ℕ} {x : α}, (xs.swapAt! i x).2.size = n
|
Subsemiring.coe_set_mk
|
Mathlib.Algebra.Ring.Subsemiring.Defs
|
∀ {R : Type u} [inst : NonAssocSemiring R] {toSubmonoid : Submonoid R}
(add_mem : ∀ {a b : R}, a ∈ toSubmonoid.carrier → b ∈ toSubmonoid.carrier → a + b ∈ toSubmonoid.carrier)
(zero_mem : 0 ∈ toSubmonoid.carrier),
↑{ toSubmonoid := toSubmonoid, add_mem' := add_mem, zero_mem' := zero_mem } = ↑toSubmonoid
|
CommSemiring.directSumGCommSemiring
|
Mathlib.Algebra.DirectSum.Ring
|
(ι : Type u_1) →
{R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommSemiring R] → DirectSum.GCommSemiring fun x => R
|
Lean.Doc.WithSyntax.rec
|
Lean.Elab.DocString
|
{α : Type u} →
{motive : Lean.Doc.WithSyntax α → Sort u_1} →
((val : α) → (stx : Lean.Syntax) → motive { val := val, stx := stx }) → (t : Lean.Doc.WithSyntax α) → motive t
|
FirstOrder.Language.Substructure.mem_top._simp_1
|
Mathlib.ModelTheory.Substructures
|
∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] (x : M), (x ∈ ⊤) = True
|
MeasureTheory.IntegrableAtFilter.neg
|
Mathlib.MeasureTheory.Integral.IntegrableOn
|
∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{l : Filter α} {f : α → E}, MeasureTheory.IntegrableAtFilter f l μ → MeasureTheory.IntegrableAtFilter (-f) l μ
|
Lean.Meta.TransparencyMode._sizeOf_inst
|
Init.MetaTypes
|
SizeOf Lean.Meta.TransparencyMode
|
PFun.bind_defined
|
Mathlib.Data.PFun
|
∀ {α : Type u_7} {β γ : Type u_8} (p : Set α) {f : α →. β} {g : β → α →. γ},
p ⊆ f.Dom → (∀ (x : β), p ⊆ (g x).Dom) → p ⊆ (f >>= g).Dom
|
Set.instCompleteAtomicBooleanAlgebra._proof_1
|
Mathlib.Data.Set.BooleanAlgebra
|
∀ {α : Type u_1} (x : Set (Set α)), ∀ t ∈ x, ∀ x_1 ∈ t, ∃ t ∈ x, x_1 ∈ t
|
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set_gt._proof_1
|
Init.Data.Array.Erase
|
∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i < j → ∀ {w : j < xs.size}, ¬i < xs.size → False
|
Real.Wallis.W._proof_2
|
Mathlib.Analysis.Real.Pi.Wallis
|
(2 + 1).AtLeastTwo
|
Filter.Eventually.self_of_nhdsWithin
|
Mathlib.Topology.NhdsWithin
|
∀ {α : Type u_1} [inst : TopologicalSpace α] {p : α → Prop} {s : Set α} {x : α},
(∀ᶠ (y : α) in nhdsWithin x s, p y) → x ∈ s → p x
|
CategoryTheory.ShortComplex.isLimitOfIsLimitπ._proof_6
|
Mathlib.Algebra.Homology.ShortComplex.Limits
|
∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (c : CategoryTheory.Limits.Cone F)
(h₂ : CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₂.mapCone c))
(h₃ : CategoryTheory.Limits.IsLimit (CategoryTheory.ShortComplex.π₃.mapCone c)) (s : CategoryTheory.Limits.Cone F),
CategoryTheory.CategoryStruct.comp (h₂.lift (CategoryTheory.ShortComplex.π₂.mapCone s)) c.pt.g =
CategoryTheory.CategoryStruct.comp s.pt.g (h₃.lift (CategoryTheory.ShortComplex.π₃.mapCone s))
|
GaloisConnection.liftOrderTop._proof_1
|
Mathlib.Order.GaloisConnection.Defs
|
∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : OrderTop β] {l : α → β}
{u : β → α}, GaloisConnection l u → ∀ (x : α), x ≤ u ⊤
|
Lean.Parser.syntaxParser.parenthesizer
|
Lean.Parser.Syntax
|
optParam ℕ 0 → Lean.PrettyPrinter.Parenthesizer
|
Filter.EventuallyConst.mul
|
Mathlib.Order.Filter.EventuallyConst
|
∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {f : α → β} [inst : Mul β] {g : α → β},
Filter.EventuallyConst f l → Filter.EventuallyConst g l → Filter.EventuallyConst (f * g) l
|
LieModuleHom.ker_id
|
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], LieModuleHom.id.ker = ⊥
|
AlgHom.liftNormal
|
Mathlib.FieldTheory.Normal.Basic
|
{F : Type u_1} →
[inst : Field F] →
{K₁ : Type u_3} →
{K₂ : Type u_4} →
[inst_1 : Field K₁] →
[inst_2 : Field K₂] →
[inst_3 : Algebra F K₁] →
[inst_4 : Algebra F K₂] →
(K₁ →ₐ[F] K₂) →
(E : Type u_6) →
[inst_5 : Field E] →
[inst_6 : Algebra F E] →
[inst_7 : Algebra K₁ E] →
[inst_8 : Algebra K₂ E] →
[IsScalarTower F K₁ E] → [IsScalarTower F K₂ E] → [h : Normal F E] → E →ₐ[F] E
|
toDual_intCast
|
Mathlib.Algebra.Order.Ring.Cast
|
∀ {R : Type u_1} [inst : IntCast R] (n : ℤ), OrderDual.toDual ↑n = ↑n
|
Lean.Expr.getForallBodyMaxDepth
|
Lean.Expr
|
ℕ → Lean.Expr → Lean.Expr
|
CoxeterSystem.map
|
Mathlib.GroupTheory.Coxeter.Basic
|
{B : Type u_1} →
{W : Type u_3} →
{H : Type u_4} →
[inst : Group W] → [inst_1 : Group H] → {M : CoxeterMatrix B} → CoxeterSystem M W → W ≃* H → CoxeterSystem M H
|
_private.Mathlib.Topology.Separation.SeparatedNhds.0.SeparatedNhds.union_left._simp_1_2
|
Mathlib.Topology.Separation.SeparatedNhds
|
∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] {a b c : α},
Disjoint (a ⊔ b) c = (Disjoint a c ∧ Disjoint b c)
|
BitVec.eq_of_getElem_eq_iff
|
Init.Data.BitVec.Bootstrap
|
∀ {n : ℕ} {x y : BitVec n}, x = y ↔ ∀ (i : ℕ) (hi : i < n), x[i] = y[i]
|
IsLinearSet.exists_fg_eq_subtypeVal
|
Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic
|
∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M},
IsLinearSet s → ∃ P s', P.FG ∧ IsLinearSet s' ∧ s = Subtype.val '' s'
|
sSup_sub
|
Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice
|
∀ {M : Type u_1} [inst : CompleteLattice M] [inst_1 : AddGroup M] [AddLeftMono M] [AddRightMono M] (s t : Set M),
sSup (s - t) = sSup s - sInf t
|
_private.Init.Data.UInt.Bitwise.0.UInt16.and_eq_neg_one_iff._simp_1_2
|
Init.Data.UInt.Bitwise
|
∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w)
|
InfHom.withTop'._proof_1
|
Mathlib.Order.Hom.WithTopBot
|
∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] [inst_2 : OrderTop β]
(f : InfHom α β) (a b : WithTop α), Option.elim (a ⊓ b) ⊤ ⇑f = Option.elim a ⊤ ⇑f ⊓ Option.elim b ⊤ ⇑f
|
CompleteLat.Iso.mk._proof_1
|
Mathlib.Order.Category.CompleteLat
|
∀ {α β : CompleteLat} (e : ↑α ≃o ↑β),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ })
(CategoryTheory.ConcreteCategory.ofHom { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ }) =
CategoryTheory.CategoryStruct.id α
|
Batteries.ByteSubarray.start_le_stop
|
Batteries.Data.ByteSlice
|
∀ (self : Batteries.ByteSubarray), self.start ≤ self.stop
|
Matrix.entryAddMonoidHom._proof_2
|
Mathlib.Data.Matrix.Basic
|
∀ {m : Type u_1} {n : Type u_2} (α : Type u_3) [inst : AddZeroClass α] (i : m) (j : n) (x x_1 : Matrix m n α),
(x + x_1) i j = (x + x_1) i j
|
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatAscFactorial._proof_1
|
Mathlib.Tactic.NormNum.NatFactorial
|
∀ {u : Lean.Level} {α : Q(Type u)} (e : Q(«$α»)) (x y : Q(ℕ)), «$e» =Q «$x».ascFactorial «$y»
|
Complex.abs_re_eq_norm._simp_1
|
Mathlib.Analysis.Complex.Norm
|
∀ {z : ℂ}, (|z.re| = ‖z‖) = (z.im = 0)
|
Vector.getElem?_setIfInBounds_self
|
Init.Data.Vector.Lemmas
|
∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x : α}, (xs.setIfInBounds i x)[i]? = if i < n then some x else none
|
Mathlib.Tactic.IntervalCases.Methods.noConfusion
|
Mathlib.Tactic.IntervalCases
|
{P : Sort u} →
{t t' : Mathlib.Tactic.IntervalCases.Methods} → t = t' → Mathlib.Tactic.IntervalCases.Methods.noConfusionType P t t'
|
Finset.sum_sq_le_sq_sum_of_nonneg
|
Mathlib.Algebra.Order.BigOperators.Ring.Finset
|
∀ {ι : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {f : ι → R}
{s : Finset ι}, (∀ i ∈ s, 0 ≤ f i) → ∑ i ∈ s, f i ^ 2 ≤ (∑ i ∈ s, f i) ^ 2
|
_private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.lTensorKerIncl
|
Mathlib.RingTheory.AdicCompletion.AsTensorProduct
|
{R : Type u} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{ι : Type} →
(f : (ι → R) →ₗ[R] M) →
TensorProduct R (AdicCompletion I R) ↥(LinearMap.ker f) →ₗ[AdicCompletion I R]
TensorProduct R (AdicCompletion I R) (ι → R)
|
AddSubmonoid.coe_neg
|
Mathlib.Algebra.Group.Submonoid.Pointwise
|
∀ {G : Type u_2} [inst : AddGroup G] (S : AddSubmonoid G), ↑(-S) = -↑S
|
GradedMonoid.GOne.mk._flat_ctor
|
Mathlib.Algebra.GradedMonoid
|
{ι : Type u_1} → {A : ι → Type u_2} → [inst : Zero ι] → A 0 → GradedMonoid.GOne A
|
_private.Mathlib.Tactic.FBinop.0.FBinopElab.hasCoeS.match_1
|
Mathlib.Tactic.FBinop
|
(motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((a : Lean.Expr) → motive (Lean.LOption.some a)) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift
|
Set.mem_sigma_iff
|
Mathlib.Data.Set.Sigma
|
∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)} {x : (i : ι) × α i},
x ∈ s.sigma t ↔ x.fst ∈ s ∧ x.snd ∈ t x.fst
|
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_pos._simp_1_1
|
Mathlib.Data.Nat.Totient
|
∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (0 < a) = (a ≠ 0)
|
HahnSeries.embDomain_notin_image_support
|
Mathlib.RingTheory.HahnSeries.Basic
|
∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R} {b : Γ'}, b ∉ ⇑f '' x.support → (HahnSeries.embDomain f x).coeff b = 0
|
FreeGroup.one_ne_of._simp_4
|
Mathlib.GroupTheory.FreeGroup.Reduce
|
∀ {α : Type u_1} (a : α), (0 = FreeAddGroup.of a) = False
|
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.equivPairAux._proof_2
|
Mathlib.GroupTheory.CoprodI
|
∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (i : ι),
{ head := 1, tail := Monoid.CoprodI.Word.empty, fstIdx_ne := ⋯ }.tail.fstIdx ≠ some i
|
_private.Lean.Elab.StructInstHint.0.Lean.Elab.Term.StructInst.FieldsHintView.openingPos
|
Lean.Elab.StructInstHint
|
Lean.Elab.Term.StructInst.FieldsHintView✝ → String.Pos.Raw
|
CategoryTheory.Comma.initial_fst
|
Mathlib.CategoryTheory.Comma.Final
|
∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) [CategoryTheory.IsCofiltered A] [CategoryTheory.IsCofiltered B] [L.Initial],
(CategoryTheory.Comma.fst L R).Initial
|
CategoryTheory.Functor.Final.coconesEquiv._proof_6
|
Mathlib.CategoryTheory.Limits.Final
|
∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E) (c : CategoryTheory.Limits.Cocone G)
(j : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Functor.Final.homToLift F j))
(c.ι.app (F.obj (CategoryTheory.Functor.Final.lift F j))))
(CategoryTheory.CategoryStruct.id c.pt) =
c.ι.app j
|
QuasiErgodic.eq_const_of_compQuasiMeasurePreserving_eq
|
Mathlib.Dynamics.Ergodic.Function
|
∀ {α : Type u_1} {X : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace X]
[TopologicalSpace.MetrizableSpace X] [Nonempty X] {f : α → α} (h : QuasiErgodic f μ) {g : α →ₘ[μ] X},
g.compQuasiMeasurePreserving f ⋯ = g → ∃ c, g = MeasureTheory.AEEqFun.const α c
|
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_6
|
Mathlib.Algebra.Order.Ring.Idempotent
|
∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
b ≤ ⟨((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2), ⋯⟩
|
OrderDual.instLocallyFiniteOrderBot
|
Mathlib.Order.Interval.Finset.Defs
|
{α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderTop α] → LocallyFiniteOrderBot αᵒᵈ
|
MeasureTheory.prob_compl_eq_zero_iff₀
|
Mathlib.MeasureTheory.Measure.Typeclasses.Probability
|
∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.NullMeasurableSet s μ → (μ sᶜ = 0 ↔ μ s = 1)
|
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_invariant.match_1_1
|
Mathlib.Logic.Function.Iterate
|
∀ (motive : ℕ → Prop) (n : ℕ), (∀ (a : Unit), motive 0) → (∀ (m : ℕ), motive m.succ) → motive n
|
CategoryTheory.Limits.image.lift_mk_factorThruImage
|
Mathlib.CategoryTheory.Limits.Shapes.Images
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image f, m := CategoryTheory.Limits.image.ι f, m_mono := ⋯,
e := CategoryTheory.Limits.factorThruImage f, fac := ⋯ })
(CategoryTheory.Limits.image.ι f) =
CategoryTheory.Limits.image.ι f
|
IsPrimitiveRoot.one
|
Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots
|
∀ {M : Type u_1} [inst : CommMonoid M], IsPrimitiveRoot 1 1
|
sign_eq_sign_or_eq_neg
|
Mathlib.Data.Sign.Defs
|
∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a b : α},
a ≠ 0 → b ≠ 0 → SignType.sign a = SignType.sign b ∨ SignType.sign a = -SignType.sign b
|
_private.Lean.Meta.CtorIdxHInj.0.Lean.Meta.initFn.match_1._@.Lean.Meta.CtorIdxHInj.1686831688._hygCtx._hyg.2
|
Lean.Meta.CtorIdxHInj
|
(motive : Option Lean.InductiveVal → Sort u_1) →
(x : Option Lean.InductiveVal) →
((indVal : Lean.InductiveVal) → motive (some indVal)) → ((x : Option Lean.InductiveVal) → motive x) → motive x
|
Module.DirectLimit.exists_of
|
Mathlib.Algebra.Colimit.Module
|
∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] {G : ι → Type u_3} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → AddCommMonoid (G i)] [inst_4 : (i : ι) → Module R (G i)] {f : (i j : ι) → i ≤ j → G i →ₗ[R] G j}
[Nonempty ι] [IsDirectedOrder ι] (z : Module.DirectLimit G f), ∃ i x, (Module.DirectLimit.of R ι G f i) x = z
|
Submodule.liftQSpanSingleton._proof_1
|
Mathlib.LinearAlgebra.Quotient.Basic
|
∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {R₂ : Type u_3}
{M₂ : Type u_4} [inst_3 : Ring R₂] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂} (x : M)
(f : M →ₛₗ[τ₁₂] M₂), f x = 0 → R ∙ x ≤ LinearMap.ker f
|
Balanced.smul_eq
|
Mathlib.Analysis.LocallyConvex.Basic
|
∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s : Set E} {a : 𝕜}, Balanced 𝕜 s → ‖a‖ = 1 → a • s = s
|
MeasureTheory.isMulLeftInvariant_map_smul
|
Mathlib.MeasureTheory.Group.Measure
|
∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Semigroup G] [MeasurableMul G] {μ : MeasureTheory.Measure G}
{α : Type u_3} [inst_3 : SMul α G] [SMulCommClass α G G] [inst_5 : MeasurableSpace α] [MeasurableSMul α G]
[μ.IsMulLeftInvariant] (a : α), (MeasureTheory.Measure.map (fun x => a • x) μ).IsMulLeftInvariant
|
Set.image_const_sub_Iic
|
Mathlib.Algebra.Order.Group.Pointwise.Interval
|
∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b : α),
(fun x => a - x) '' Set.Iic b = Set.Ici (a - b)
|
AnalyticAt.compContinuousLinearMap
|
Mathlib.Analysis.Analytic.Constructions
|
∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {u : E →L[𝕜] F} {f : F → G} {x : E},
AnalyticAt 𝕜 f (u x) → AnalyticAt 𝕜 (f ∘ ⇑u) x
|
PresheafOfModules.restrictScalarsCompToPresheaf
|
Mathlib.Algebra.Category.ModuleCat.Presheaf.ChangeOfRings
|
{C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{R R' : CategoryTheory.Functor Cᵒᵖ RingCat} →
(α : R ⟶ R') →
(PresheafOfModules.restrictScalars α).comp (PresheafOfModules.toPresheaf R) ≅ PresheafOfModules.toPresheaf R'
|
Homeomorph.sumCongr_refl
|
Mathlib.Topology.Constructions.SumProd
|
∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
(Homeomorph.refl X).sumCongr (Homeomorph.refl Y) = Homeomorph.refl (X ⊕ Y)
|
Lean.Parser.levelParser
|
Lean.Parser.Level
|
optParam ℕ 0 → Lean.Parser.Parser
|
_private.Mathlib.RingTheory.OreLocalization.Basic.0.OreLocalization.add'._proof_1
|
Mathlib.RingTheory.OreLocalization.Basic
|
∀ {R : Type u_2} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_1}
[inst_2 : AddMonoid X] [inst_3 : DistribMulAction R X] (r₂ : X) (s₂ : ↥S) (a b : X × ↥S),
a ≈ b → OreLocalization.add''✝ a.1 a.2 r₂ s₂ = OreLocalization.add''✝¹ b.1 b.2 r₂ s₂
|
Real.binEntropy_le_log_two
|
Mathlib.Analysis.SpecialFunctions.BinaryEntropy
|
∀ {p : ℝ}, Real.binEntropy p ≤ Real.log 2
|
Mathlib.MoveAdd.tacticMove_add_
|
Mathlib.Tactic.MoveAdd
|
Lean.ParserDescr
|
CategoryTheory.ObjectProperty.le_strictLimitsClosureStep._simp_1
|
Mathlib.CategoryTheory.ObjectProperty.LimitsClosure
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C) {α : Type t}
(J : α → Type u') [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)],
(P ≤ P.strictLimitsClosureStep J) = True
|
Pi.isRegular_iff._simp_4
|
Mathlib.Algebra.Regular.Pi
|
∀ {ι : Type u_1} {R : ι → Type u_3} [inst : (i : ι) → Add (R i)] {a : (i : ι) → R i},
IsAddRegular a = ∀ (i : ι), IsAddRegular (a i)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.