name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Aesop.Frontend.RuleExpr.rec_2 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.node f children)) →
((toList : List Aesop.Frontend.RuleExpr) → motive_3 toList → motive_2 { toList := toList }) →
motive_3 [] →
((head : Aesop.Frontend.RuleExpr) →
(tail : List Aesop.Frontend.RuleExpr) → motive_1 head → motive_3 tail → motive_3 (head :: tail)) →
(t : List Aesop.Frontend.RuleExpr) → motive_3 t |
ContinuousMap.HomotopyEquiv | Mathlib.Topology.Homotopy.Equiv | (X : Type u) → (Y : Type v) → [TopologicalSpace X] → [TopologicalSpace Y] → Type (max u v) |
SimpleGraph.instDecidableEqWalk.decEq._proof_5 | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} (a a_1 a_2 : V) (a_3 : G.Adj a a_2) (a_4 b : G.Walk a_2 a_1),
¬a_4 = b → ¬SimpleGraph.Walk.cons a_3 a_4 = SimpleGraph.Walk.cons a_3 b |
Lean.Meta.Grind.Arith.CommRing.RingM.Context | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Type |
_private.Mathlib.Data.Prod.Lex.0.Prod.Lex.toLex_lt_toLex'._simp_1_2 | Mathlib.Data.Prod.Lex | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) |
TensorProduct.rightComm._proof_16 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R (TensorProduct R M N) P) |
MulOpposite.instAddGroupWithOne._proof_5 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℕ) (a : Rᵐᵒᵖ),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
Std.DTreeMap.Internal.Impl.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[Std.LawfulEqOrd α], t.WF → ∀ {k : α} {f : β → β}, (Std.DTreeMap.Internal.Impl.Const.modify k f t).minKey? = t.minKey? |
_private.Lean.Elab.PreDefinition.Basic.0.Lean.Elab.getLevelParamsPreDecls | Lean.Elab.PreDefinition.Basic | Array Lean.Elab.PreDefinition → List Lean.Name → List Lean.Name → Lean.Elab.TermElabM (List Lean.Name) |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.lintFile.match_3 | Mathlib.Tactic.Linter.TextBased | (motive : Option (Array String) → Sort u_1) →
(changes : Option (Array String)) →
((c : Array String) → motive (some c)) → ((x : Option (Array String)) → motive x) → motive changes |
cfcₙ_tsub._auto_9 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax |
Nat.pos_of_neZero | Init.Data.Nat.Basic | ∀ (n : ℕ) [NeZero n], 0 < n |
CommRingCat.Colimits.Relation.below.mul_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop}
(x : CommRingCat.Colimits.Prequotient F), CommRingCat.Colimits.Relation.below ⋯ |
contDiff_const_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] (c : R), ContDiff 𝕜 n fun p => c • p |
ContinuousMap.Homotopy.trans._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous fun x => ↑x.1 |
Lean.RArray.toExpr | Lean.Data.RArray | {α : Type u_1} → Lean.Expr → (α → Lean.Expr) → Lean.RArray α → Lean.MetaM Lean.Expr |
Std.Mutex.mutex | Std.Sync.Mutex | {α : Type} → Std.Mutex α → Std.BaseMutex |
Lean.Doc.Data.SetOption.noConfusionType | Lean.Elab.DocString.Builtin | Sort u → Lean.Doc.Data.SetOption → Lean.Doc.Data.SetOption → Sort u |
two_nsmul_inf_eq_add_sub_abs_sub | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b : α), 2 • (a ⊓ b) = a + b - |b - a| |
List.isSome_isPrefixOf?_eq_isPrefixOf | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (xs ys : List α), (xs.isPrefixOf? ys).isSome = xs.isPrefixOf ys |
Lean.Lsp.TextDocumentEdit.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (textDocument : Lean.Lsp.VersionedTextDocumentIdentifier) (edits : Lean.Lsp.TextEditBatch),
sizeOf { textDocument := textDocument, edits := edits } = 1 + sizeOf textDocument + sizeOf edits |
MulAction.isTopologicallyTransitive_iff | Mathlib.Dynamics.Transitive | ∀ (M : Type u_1) {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : Monoid M] [inst_2 : MulAction M α],
MulAction.IsTopologicallyTransitive M α ↔
∀ {U V : Set α}, IsOpen U → U.Nonempty → IsOpen V → V.Nonempty → ∃ m, (m • U ∩ V).Nonempty |
EuclideanGeometry.inner_pos_or_eq_of_dist_le_radius | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → dist p₂ s.center ≤ s.radius → 0 < inner ℝ (p₁ -ᵥ p₂) (p₁ -ᵥ s.center) ∨ p₁ = p₂ |
Lean.Compiler.LCNF.CSE.State._sizeOf_1 | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.CSE.State → ℕ |
Lean.Elab.Do.ControlLifter.mk | Lean.Elab.Do.Control | Lean.Elab.Do.DoElemCont →
Option Lean.Elab.Do.ControlStack →
Option Lean.Elab.Do.ControlStack →
Option Lean.Elab.Do.ControlStack →
Lean.Elab.Do.ControlStack → Lean.Elab.Do.CodeLiveness → Lean.Expr → Lean.Elab.Do.ControlLifter |
Lean.Linter.whenLinterActivated | Mathlib.Lean.Linter | Lean.Option Bool → Lean.Elab.Command.CommandElab → optParam Bool true → Lean.Elab.Command.CommandElab |
SpecialLinearGroup.SL2Z_generators | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | Subgroup.closure {ModularGroup.S, ModularGroup.T} = ⊤ |
Int64.toUInt64_neg | Init.Data.SInt.Lemmas | ∀ (a : Int64), (-a).toUInt64 = -a.toUInt64 |
Multipliable.tprod_subtype_mul_tprod_subtype_compl | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : CommGroup α] [inst_1 : UniformSpace α] [IsUniformGroup α] [CompleteSpace α]
[T2Space α] {f : β → α}, Multipliable f → ∀ (s : Set β), (∏' (x : ↑s), f ↑x) * ∏' (x : ↑sᶜ), f ↑x = ∏' (x : β), f x |
ContinuousAffineMap.comp_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {W₂ : Type u_6} {Q₂ : Type u_7}
[inst_9 : AddCommGroup W₂] [inst_10 : Module R W₂] [inst_11 : TopologicalSpace Q₂] [inst_12 : AddTorsor W₂ Q₂]
[inst_13 : TopologicalSpace V] [inst_14 : IsTopologicalAddTorsor P] [inst_15 : TopologicalSpace W]
[inst_16 : IsTopologicalAddTorsor Q] [inst_17 : TopologicalSpace W₂] [inst_18 : IsTopologicalAddTorsor Q₂]
(f : P →ᴬ[R] Q) (g : Q →ᴬ[R] Q₂), (g.comp f).contLinear = g.contLinear.comp f.contLinear |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) |
DyckWord.ctorIdx | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → ℕ |
Std.IterM.toIter_mk | Init.Data.Iterators.Basic | ∀ {α β : Type u_1} {it : α}, { internalState := it }.toIter = { internalState := it } |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.markRhss.match_1 | Lean.Elab.Quotation | (motive : Lean.TSyntax `term × Lean.TSyntax `term → Sort u_1) →
(__discr : Lean.TSyntax `term × Lean.TSyntax `term) →
((idx rhs : Lean.TSyntax `term) → motive (idx, rhs)) → motive __discr |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ_of_pos._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α} {i : ℕ} {a : α},
p a = true → List.countPBefore p (a :: xs) (i + 1) = List.countPBefore p xs i + 1 |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'.congr_simp | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n),
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h =
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h |
IsLocalization.exists_mk'_eq | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (z : S), ∃ x y, IsLocalization.mk' S x y = z |
MeasureTheory.SimpleFunc.instNonAssocRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocRing β] (a : MeasureTheory.SimpleFunc α β),
0 * a = 0 |
Mathlib.Tactic.Push.elabHead | Mathlib.Tactic.Push | Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.Push.Head |
_private.Init.Data.List.Nat.BEq.0.List.beq_eq_isEqv._simp_1_2 | Init.Data.List.Nat.BEq | ∀ {n : ℕ} {p : (m : ℕ) → m < n + 1 → Prop},
(∀ (m : ℕ) (h : m < n + 1), p m h) = (p 0 ⋯ ∧ ∀ (m : ℕ) (h : m < n), p (m + 1) ⋯) |
Char.toUpper_toUpper_eq_toUpper | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), c.toUpper.toUpper = c.toUpper |
Aesop.Frontend.RuleExpr.rec_1 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.node f children)) →
((toList : List Aesop.Frontend.RuleExpr) → motive_3 toList → motive_2 { toList := toList }) →
motive_3 [] →
((head : Aesop.Frontend.RuleExpr) →
(tail : List Aesop.Frontend.RuleExpr) → motive_1 head → motive_3 tail → motive_3 (head :: tail)) →
(t : Array Aesop.Frontend.RuleExpr) → motive_2 t |
LinearEquiv.toSpanNonzeroSingleton._proof_4 | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] (x : M), x ≠ 0 → Function.Injective ⇑(LinearMap.toSpanSingleton R M x) |
Polynomial.algebra | Mathlib.RingTheory.PolynomialAlgebra | (R : Type u_1) →
(A : Type u_3) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra (Polynomial R) (Polynomial A) |
ContinuousMulEquiv.trans.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (cme1 : M ≃ₜ* N) (cme2 : N ≃ₜ* L),
cme1.trans cme2 = { toMulEquiv := cme1.trans cme2.toMulEquiv, continuous_toFun := ⋯, continuous_invFun := ⋯ } |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.three_le_length.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V}
(motive : (p : G.Walk v v) → p.IsCycle → p.IsTrail → p ≠ SimpleGraph.Walk.nil → p.support.tail.Nodup → Prop)
(p : G.Walk v v) (hp : p.IsCycle) (hp_1 : p.IsTrail) (hp' : p ≠ SimpleGraph.Walk.nil)
(support_nodup : p.support.tail.Nodup),
(∀ (hp : SimpleGraph.Walk.nil.IsCycle) (hp_2 : SimpleGraph.Walk.nil.IsTrail)
(hp' : SimpleGraph.Walk.nil ≠ SimpleGraph.Walk.nil) (support_nodup : SimpleGraph.Walk.nil.support.tail.Nodup),
motive SimpleGraph.Walk.nil hp hp_2 hp' support_nodup) →
(∀ (h : G.Adj v v) (hp : (SimpleGraph.Walk.cons h SimpleGraph.Walk.nil).IsCycle)
(hp_2 : (SimpleGraph.Walk.cons h SimpleGraph.Walk.nil).IsTrail)
(hp' : SimpleGraph.Walk.cons h SimpleGraph.Walk.nil ≠ SimpleGraph.Walk.nil)
(support_nodup : (SimpleGraph.Walk.cons h SimpleGraph.Walk.nil).support.tail.Nodup),
motive (SimpleGraph.Walk.cons h SimpleGraph.Walk.nil) hp hp_2 hp' support_nodup) →
(∀ (v_1 : V) (h : G.Adj v v_1) (h_3 : G.Adj v_1 v)
(hp : (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_3 SimpleGraph.Walk.nil)).IsCycle)
(hp_2 : (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_3 SimpleGraph.Walk.nil)).IsTrail)
(hp' : SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_3 SimpleGraph.Walk.nil) ≠ SimpleGraph.Walk.nil)
(support_nodup :
(SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_3 SimpleGraph.Walk.nil)).support.tail.Nodup),
motive (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_3 SimpleGraph.Walk.nil)) hp hp_2 hp' support_nodup) →
(∀ (v_1 : V) (h : G.Adj v v_1) (v_2 : V) (h_4 : G.Adj v_1 v_2) (v_3 : V) (h_5 : G.Adj v_2 v_3)
(p : G.Walk v_3 v)
(hp : (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_4 (SimpleGraph.Walk.cons h_5 p))).IsCycle)
(hp_2 : (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_4 (SimpleGraph.Walk.cons h_5 p))).IsTrail)
(hp' :
SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_4 (SimpleGraph.Walk.cons h_5 p)) ≠ SimpleGraph.Walk.nil)
(support_nodup :
(SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_4 (SimpleGraph.Walk.cons h_5 p))).support.tail.Nodup),
motive (SimpleGraph.Walk.cons h (SimpleGraph.Walk.cons h_4 (SimpleGraph.Walk.cons h_5 p))) hp hp_2 hp'
support_nodup) →
motive p hp hp_1 hp' support_nodup |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) |
isOpen_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ nhds x → s ∈ l |
OrderMonoidIso.instEquivLike.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β],
OrderMonoidIso.instEquivLike =
{ coe := fun f => f.toFun, inv := fun f => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ } |
AddCommGrpCat.Forget₂.createsLimit._proof_7 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections)
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp
((CategoryTheory.forget₂ AddCommGrpCat AddGrpCat).comp
(CategoryTheory.forget₂ AddGrpCat AddMonCat))).comp
(CategoryTheory.forget AddMonCat)).sections)
⟨fun j =>
((CategoryTheory.forget AddMonCat).mapCone
(((CategoryTheory.forget₂ AddCommGrpCat AddGrpCat).comp
(CategoryTheory.forget₂ AddGrpCat AddMonCat)).mapCone
s)).π.app
j 0,
⋯⟩ =
0 |
Hyperreal.infinitePos_mul_of_not_infinitesimal_pos_infinitePos | Mathlib.Analysis.Real.Hyperreal | ∀ {x y : ℝ*}, ¬x.Infinitesimal → 0 < x → y.InfinitePos → (x * y).InfinitePos |
Lean.Grind.IntInterval.isFinite.eq_4 | Init.Grind.ToInt | Lean.Grind.IntInterval.ii.isFinite = false |
Complex.cderiv._proof_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | (1 + 1).AtLeastTwo |
Fin.castSucc_eq_zero_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, (a.castSucc = 0) = (a = 0) |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_oneMore_of_utf8DecodeChar?_eq_some._proof_1_3 | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char}, c.utf8Size = 2 → c.utf8Size = 3 → False |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_comp._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
(p.comp q = 0) = (p = 0 ∨ Polynomial.eval (q.coeff 0) p = 0 ∧ q = Polynomial.C (q.coeff 0)) |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_convRing_nf!__1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro |
SimpleGraph.UnitDistEmbedding.subsingleton._proof_2 | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | ∀ {V : Type u_1} {E : Type u_2} [Subsingleton V] (x : E), Function.Injective fun x_1 => x |
hasSum_fourier_series_of_summable | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ} [hT : Fact (0 < T)] {f : C(AddCircle T, ℂ)},
Summable (fourierCoeff ⇑f) → HasSum (fun i => fourierCoeff (⇑f) i • fourier i) f |
CategoryTheory.PreGaloisCategory.IsNaturalSMul.casesOn | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
{G : Type u_1} →
[inst_1 : Group G] →
[inst_2 : (X : C) → MulAction G (F.obj X).carrier] →
{motive : CategoryTheory.PreGaloisCategory.IsNaturalSMul F G → Sort u} →
(t : CategoryTheory.PreGaloisCategory.IsNaturalSMul F G) →
((naturality :
∀ (g : G) {X Y : C} (f : X ⟶ Y) (x : (F.obj X).carrier),
(CategoryTheory.ConcreteCategory.hom (F.map f)) (g • x) =
g • (CategoryTheory.ConcreteCategory.hom (F.map f)) x) →
motive ⋯) →
motive t |
CategoryTheory.Functor.FullyFaithful.homNatIsoMaxRight | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{max v₁ v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
F.FullyFaithful →
(X : C) → F.op.comp (CategoryTheory.yoneda.obj (F.obj X)) ≅ CategoryTheory.uliftYoneda.{v₂, v₁, u₁}.obj X |
_private.Mathlib.Analysis.Polynomial.CauchyBound.0.Polynomial.IsRoot.norm_lt_cauchyBound._simp_1_10 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
Finset.Nonempty.of_image | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α},
(Finset.image f s).Nonempty → s.Nonempty |
CategoryTheory.surjective_up_to_refinements_of_epi | Mathlib.CategoryTheory.Abelian.Refinements | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Epi f] {A : C} (y : A ⟶ Y),
∃ A' π,
∃ (_ : CategoryTheory.Epi π), ∃ x, CategoryTheory.CategoryStruct.comp π y = CategoryTheory.CategoryStruct.comp x f |
SimpleGraph.Hom.injective_of_top_hom | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G' : SimpleGraph W} (f : ⊤ →g G'), Function.Injective ⇑f |
Std.Do.WP.liftWith_refl | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {α : Type u} {Q : Std.Do.PostCond α ps} [inst : Std.Do.WP m ps]
[inst_1 : Pure m] (f : ({β : Type u} → m β → m β) → m α),
(Std.Do.wp (liftWith f)).apply Q = (Std.Do.wp (f fun {β} x => x)).apply Q |
ENat.LEInfty.out | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {m : WithTop ℕ∞} [self : ENat.LEInfty m], m ≤ ↑⊤ |
Lean.Compiler.LCNF.TraverseFVar.forFVarM | Lean.Compiler.LCNF.FVarUtil | {α : Type} →
[self : Lean.Compiler.LCNF.TraverseFVar α] → {m : Type → Type} → [Monad m] → (Lean.FVarId → m Unit) → α → m Unit |
Lean.Meta.initFn._@.Lean.Meta.Tactic.Intro.3089346791._hygCtx._hyg.4 | Lean.Meta.Tactic.Intro | IO (Lean.Option Bool) |
isClosed_of_mem_irreducibleComponents | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X], ∀ s ∈ irreducibleComponents X, IsClosed s |
Std.DHashMap.containsThenInsertIfNew_fst | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α} {v : β k},
(m.containsThenInsertIfNew k v).1 = m.contains k |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.lratChecker.match_3.eq_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_1} {β : Type u_2} (motive : List (Std.Tactic.BVDecide.LRAT.Action β α) → Sort u_3) (id : ℕ) (c : β)
(rupHints : Array ℕ) (restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) (h_1 : Unit → motive [])
(h_2 :
(id : ℕ) →
(rupHints : Array ℕ) →
(tail : List (Std.Tactic.BVDecide.LRAT.Action β α)) →
motive (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints :: tail))
(h_3 :
(id : ℕ) →
(c : β) →
(rupHints : Array ℕ) →
(restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) →
motive (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints :: restPrf))
(h_4 :
(id : ℕ) →
(c : β) →
(pivot : Std.Sat.Literal α) →
(rupHints : Array ℕ) →
(ratHints : Array (ℕ × Array ℕ)) →
(restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) →
motive (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints :: restPrf))
(h_5 :
(ids : Array ℕ) →
(restPrf : List (Std.Tactic.BVDecide.LRAT.Action β α)) →
motive (Std.Tactic.BVDecide.LRAT.Action.del ids :: restPrf)),
(match Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints :: restPrf with
| [] => h_1 ()
| Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints :: tail => h_2 id rupHints tail
| Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints :: restPrf => h_3 id c rupHints restPrf
| Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints :: restPrf =>
h_4 id c pivot rupHints ratHints restPrf
| Std.Tactic.BVDecide.LRAT.Action.del ids :: restPrf => h_5 ids restPrf) =
h_3 id c rupHints restPrf |
le_of_forall_neg_add_le | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] [DenselyOrdered α] {a b : α},
(∀ ε < 0, a + ε ≤ b) → a ≤ b |
IsCompact.closedBall_zero_add | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {δ : ℝ} {s : Set E},
IsCompact s → 0 ≤ δ → Metric.closedBall 0 δ + s = Metric.cthickening δ s |
IsUpperSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsUpperSet s → IsLowerSet sᶜ |
HomotopicalAlgebra.CofibrantObject.toHoCatLocalizerMorphism | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
CategoryTheory.LocalizerMorphism (HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject C))
(HomotopicalAlgebra.weakEquivalences (HomotopicalAlgebra.CofibrantObject.HoCat C)) |
PowerBasis.trace_gen_eq_nextCoeff_minpoly | Mathlib.RingTheory.Trace.Basic | ∀ {S : Type u_2} [inst : CommRing S] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra K S] [Nontrivial S]
(pb : PowerBasis K S), (Algebra.trace K S) pb.gen = -(minpoly K pb.gen).nextCoeff |
Lean.Level.hash | Lean.Level | Lean.Level → UInt64 |
Real.Angle.two_zsmul_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = 0 ↔ θ = 0 ∨ θ = ↑Real.pi |
Int.toList_rcc_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {xs : List ℤ} {m n a : ℤ}, ((m...=n).toList = a :: xs) = (m = a ∧ m ≤ n ∧ ((m + 1)...=n).toList = xs) |
CategoryTheory.Functor.mapIso_hom | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (i : X ≅ Y), (F.mapIso i).hom = F.map i.hom |
inner_map_complex | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {G : Type u_4} [inst : SeminormedAddCommGroup G] [inst_1 : InnerProductSpace ℝ G] (f : G ≃ₗᵢ[ℝ] ℂ) (x y : G),
inner ℝ x y = (f y * (starRingEnd ℂ) (f x)).re |
OpenPartialHomeomorph.IsImage.iff_symm_preimage_eq | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y}, e.IsImage s t ↔ e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t |
Submodule.prod_comap_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (q : Submodule R M₂),
Submodule.comap (LinearMap.inr R M M₂) (p.prod q) = q |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine.noConfusion | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {P : Sort u} →
{c₁ c₂ c₁' c₂' : Lean.Meta.Grind.Arith.Linear.IneqCnstr} →
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁ c₂ =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.combine c₁' c₂' →
(c₁ = c₁' → c₂ = c₂' → P) → P |
MeasureTheory.Integrable.congr' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] [inst_1 : NormedAddCommGroup γ] {f : α → β} {g : α → γ},
MeasureTheory.Integrable f μ →
MeasureTheory.AEStronglyMeasurable g μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → MeasureTheory.Integrable g μ |
CategoryTheory.ShortComplex.SnakeInput.v₂₃ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] → (self : CategoryTheory.ShortComplex.SnakeInput C) → self.L₂ ⟶ self.L₃ |
Nat.factorization_centralBinom_eq_zero_of_two_mul_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n : ℕ}, 2 * n < p → n.centralBinom.factorization p = 0 |
isCompact_Ioo_iff._simp_1 | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsCompact (Set.Ioo a b) = (b ≤ a) |
Lean.Elab.Structural.RecArgInfo.fixedParamPerm | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → Lean.Elab.FixedParamPerm |
Lean.Elab.Term.elabLetRec._regBuiltin.Lean.Elab.Term.elabLetRec.declRange_3 | Lean.Elab.LetRec | IO Unit |
IntermediateField.sum_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{ι : Type u_4} {t : Finset ι} {f : ι → L}, (∀ c ∈ t, f c ∈ S) → ∑ i ∈ t, f i ∈ S |
AugmentedSimplexCategory.equivAugmentedSimplicialObjectFunctorCompDropIso | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
AugmentedSimplexCategory.equivAugmentedSimplicialObject.functor.comp
CategoryTheory.SimplicialObject.Augmented.drop ≅
(CategoryTheory.Functor.whiskeringLeft SimplexCategoryᵒᵖ AugmentedSimplexCategoryᵒᵖ C).obj
AugmentedSimplexCategory.inclusion.op |
CategoryTheory.EnrichedCat.bicategory._proof_4 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} (f : CategoryTheory.EnrichedFunctor V ↑a ↑b)
{g h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (η : g ⟶ h) (θ : h ⟶ i),
CategoryTheory.EnrichedCat.whiskerLeft f (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.whiskerLeft f η)
(CategoryTheory.EnrichedCat.whiskerLeft f θ) |
HomologicalComplex.extend_d_to_eq_zero | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) (e : c.Embedding c') (i' j' : ι')
(j : ι), e.f j = j' → ¬c.Rel (c.prev j) j → (K.extend e).d i' j' = 0 |
MeasureTheory.SimpleFunc.setToSimpleFunc_mono | Mathlib.MeasureTheory.Integral.FinMeasAdditive | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G' : Type u_7} {G'' : Type u_8}
[inst : NormedAddCommGroup G''] [inst_1 : PartialOrder G''] [IsOrderedAddMonoid G''] [inst_3 : NormedSpace ℝ G'']
[inst_4 : NormedAddCommGroup G'] [inst_5 : PartialOrder G'] [inst_6 : NormedSpace ℝ G'] [IsOrderedAddMonoid G']
{T : Set α → G' →L[ℝ] G''},
MeasureTheory.FinMeasAdditive μ T →
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x) →
∀ {f g : MeasureTheory.SimpleFunc α G'},
MeasureTheory.Integrable (⇑f) μ →
MeasureTheory.Integrable (⇑g) μ →
f ≤ g → MeasureTheory.SimpleFunc.setToSimpleFunc T f ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T g |
Matrix.SpecialLinearGroup.instPowNat | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | {n : Type u} →
[inst : DecidableEq n] →
[inst_1 : Fintype n] → {R : Type v} → [inst_2 : CommRing R] → Pow (Matrix.SpecialLinearGroup n R) ℕ |
ENNReal.ofNNReal_add_natCast | Mathlib.Data.ENNReal.Basic | ∀ (r : NNReal) (n : ℕ), ↑(r + ↑n) = ↑r + ↑n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_toList._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
WithZero.not_lt_zero | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LT α] (a : WithZero α), ¬a < 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.