name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Complex.isCauSeq_exp | Mathlib.Analysis.Complex.Exponential | ∀ (z : ℂ), IsCauSeq (fun x => ‖x‖) fun n => ∑ m ∈ Finset.range n, z ^ m / ↑m.factorial |
List.monotone_sum_take | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] (L : List M),
Monotone fun i => (List.take i L).sum |
CategoryTheory.Bicategory.Prod.snd_map₂ | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] {a b : B × C}
{f g : a ⟶ b} (a_1 : f ⟶ g), (CategoryTheory.Bicategory.Prod.snd B C).map₂ a_1 = a_1.2 |
ContinuousMap.Homotopy.ulift_apply | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X Y : TopCat} {f g : C(↑X, ↑Y)} (H : f.Homotopy g) (i : ULift.{u, 0} ↑unitInterval) (x : ↑X),
H.uliftMap (i, x) = H (i.down, x) |
Finsupp.coe_mk | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] (f : α → M) (s : Finset α) (h : ∀ (a : α), a ∈ s ↔ f a ≠ 0),
⇑{ support := s, toFun := f, mem_support_toFun := h } = f |
UInt16.ofNatTruncate_toNat | Init.Data.UInt.Lemmas | ∀ (n : UInt16), UInt16.ofNatTruncate n.toNat = n |
Int.getElem_toList_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ} (_h : i < (m<...n).toList.length), (m<...n).toList[i] = m + 1 + ↑i |
Rep.coinvariantsTensorIndInv._proof_2 | Mathlib.RepresentationTheory.Induced | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H) (A : Rep k G) (B : Rep k H),
SMulCommClass k k (((CategoryTheory.MonoidalCategory.curriedTensor (Rep k H)).obj (Rep.ind φ A)).obj B).ρ.Coinvariants |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.mdifferentiableWithinAt_congr_set'._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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 : M → M'} {x : M} {s : Set M},
MDifferentiableWithinAt I I' f s x = ∃ f', HasMFDerivWithinAt I I' f s x f' |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra.0.CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.ext.match_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | ∀ {C : Type u_5} {inst : CategoryTheory.Category.{u_3, u_5} C}
{F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat)}
{ι : Type u_1} {S : C} {X : ι → C} {f : (i : ι) → X i ⟶ S} {D₁ D₂ : F.DescentDataAsCoalgebra f}
(motive : D₁.Hom D₂ → Prop) (h : D₁.Hom D₂),
(∀ (hom : (i : ι) → D₁.obj i ⟶ D₂.obj i)
(comm :
autoParam
(∀ (i₁ i₂ : ι),
CategoryTheory.CategoryStruct.comp (D₁.hom i₁ i₂)
((F.map (f i₁).op.toLoc).l.toFunctor.map ((F.map (f i₂).op.toLoc).r.toFunctor.map (hom i₂))) =
CategoryTheory.CategoryStruct.comp (hom i₁) (D₂.hom i₁ i₂))
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.comm._autoParam),
motive { hom := hom, comm := comm }) →
motive h |
Std.DTreeMap.Internal.Impl.length_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.keys.length = t.size |
_private.Aesop.RuleTac.Cases.0.Aesop.RuleTac.cases.go.match_10 | Aesop.RuleTac.Cases | (motive : Option (Array Lean.Meta.CasesSubgoal) → Sort u_1) →
(__discr : Option (Array Lean.Meta.CasesSubgoal)) →
((goals : Array Lean.Meta.CasesSubgoal) → motive (some goals)) →
((x : Option (Array Lean.Meta.CasesSubgoal)) → motive x) → motive __discr |
List.getLast._proof_1 | Init.Data.List.Basic | ∀ {α : Type u_1}, [] = [] |
MeasureTheory.Measure.AbsolutelyContinuous.support_mono | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ ν : MeasureTheory.Measure X},
μ.AbsolutelyContinuous ν → μ.support ⊆ ν.support |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.error.noConfusion | Mathlib.Tactic.TacticAnalysis.Declarations | {P : Sort u} →
{stx : Lean.TSyntax `tactic} →
{msg : Lean.MessageData} →
{stx' : Lean.TSyntax `tactic} →
{msg' : Lean.MessageData} →
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝ stx msg =
Mathlib.TacticAnalysis.TerminalReplacementOutcome.error✝¹ stx' msg' →
(stx = stx' → msg = msg' → P) → P |
DirectSum.GSemiring.casesOn | Mathlib.Algebra.DirectSum.Ring | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : AddMonoid ι] →
[inst_1 : (i : ι) → AddCommMonoid (A i)] →
{motive : DirectSum.GSemiring A → Sort u} →
(t : DirectSum.GSemiring A) →
([toGNonUnitalNonAssocSemiring : DirectSum.GNonUnitalNonAssocSemiring A] →
[toGOne : GradedMonoid.GOne A] →
(one_mul : ∀ (a : GradedMonoid A), 1 * a = a) →
(mul_one : ∀ (a : GradedMonoid A), a * 1 = a) →
(mul_assoc : ∀ (a b c : GradedMonoid A), a * b * c = a * (b * c)) →
(gnpow : (n : ℕ) → {i : ι} → A i → A (n • i)) →
(gnpow_zero' : ∀ (a : GradedMonoid A), GradedMonoid.mk (0 • a.fst) (gnpow 0 a.snd) = 1) →
(gnpow_succ' :
∀ (n : ℕ) (a : GradedMonoid A),
GradedMonoid.mk (n.succ • a.fst) (gnpow n.succ a.snd) =
⟨n • a.fst, gnpow n a.snd⟩ * a) →
(natCast : ℕ → A 0) →
(natCast_zero : natCast 0 = 0) →
(natCast_succ : ∀ (n : ℕ), natCast (n + 1) = natCast n + GradedMonoid.GOne.one) →
motive
{ toGNonUnitalNonAssocSemiring := toGNonUnitalNonAssocSemiring, toGOne := toGOne,
one_mul := one_mul, mul_one := mul_one, mul_assoc := mul_assoc, gnpow := gnpow,
gnpow_zero' := gnpow_zero', gnpow_succ' := gnpow_succ', natCast := natCast,
natCast_zero := natCast_zero, natCast_succ := natCast_succ }) →
motive t |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_13 | Lean.Elab.Tactic.Simp | (motive : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(x : Lean.Syntax × Lean.Elab.Tactic.ElabSimpArgResult) →
((ref : Lean.Syntax) → (arg : Lean.Elab.Tactic.ElabSimpArgResult) → motive (ref, arg)) → motive x |
Std.Tactic.BVDecide.LRAT.Internal.lratChecker._unsafe_rec | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | {α : Type u_1} →
{β : Type u_2} →
{σ : Type u_3} →
[DecidableEq α] →
[inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] →
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] →
[Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] →
σ → List (Std.Tactic.BVDecide.LRAT.Action β α) → Std.Tactic.BVDecide.LRAT.Internal.Result |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_iff_forall_isSome_getEntry?.match_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} (motive : List ((a : α) × β a) → Prop) (x : List ((a : α) × β a)),
(∀ (a : Unit), motive []) → (∀ (k : α) (v : β k) (l : List ((a : α) × β a)), motive (⟨k, v⟩ :: l)) → motive x |
Finset.piecewise | Mathlib.Data.Finset.Piecewise | {ι : Type u_1} →
{π : ι → Sort u_2} →
(s : Finset ι) → ((i : ι) → π i) → ((i : ι) → π i) → [(j : ι) → Decidable (j ∈ s)] → (i : ι) → π i |
PhragmenLindelof.eq_zero_on_quadrant_IV | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E},
DiffContOnCl ℂ f (Set.Ioi 0 ×ℂ Set.Iio 0) →
(∃ c < 2,
∃ B, f =O[Bornology.cobounded ℂ ⊓ Filter.principal (Set.Ioi 0 ×ℂ Set.Iio 0)] fun z => Real.exp (B * ‖z‖ ^ c)) →
(∀ (x : ℝ), 0 ≤ x → f ↑x = 0) → (∀ x ≤ 0, f (↑x * Complex.I) = 0) → Set.EqOn f 0 {z | 0 ≤ z.re ∧ z.im ≤ 0} |
_private.Mathlib.Topology.Order.LeftRightLim.0.Monotone.leftLim_le._simp_1_4 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) |
Monotone.withTop_map | Mathlib.Order.WithBot | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Monotone f → Monotone (WithTop.map f) |
npow_mul_comm | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (m n : ℕ) (x : M),
x ^ m * x ^ n = x ^ n * x ^ m |
MonCat.Colimits.quot_one | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat),
Quot.mk (⇑(MonCat.Colimits.colimitSetoid F)) MonCat.Colimits.Prequotient.one = 1 |
IsLocalHomeomorphOn.of_comp_left | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {g : Y → Z} {f : X → Y} {s : Set X},
IsLocalHomeomorphOn (g ∘ f) s → IsLocalHomeomorphOn g (f '' s) → (∀ x ∈ s, ContinuousAt f x) → IsLocalHomeomorphOn f s |
AddChar.PrimitiveAddChar.char | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | {R : Type u} →
[inst : CommRing R] →
{R' : Type v} →
[inst_1 : Field R'] → (self : AddChar.PrimitiveAddChar R R') → AddChar R (CyclotomicField (↑self.n) R') |
MulEquiv.coe_subgroupMap_apply | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (e : G ≃* G') (H : Subgroup G) (g : ↥H),
↑((e.subgroupMap H) g) = e ↑g |
Polynomial.expand_eq_zero | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] {p : ℕ}, 0 < p → ∀ {f : Polynomial R}, (Polynomial.expand R p) f = 0 ↔ f = 0 |
MeasureTheory.measureReal_univ_pos | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] [NeZero μ],
0 < μ.real Set.univ |
LieModuleHom.codRestrict.congr_simp | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : LieRingModule L N] (P : LieSubmodule R L N) (f f_1 : M →ₗ⁅R,L⁆ N) (e_f : f = f_1)
(h : ∀ (m : M), f m ∈ P), LieModuleHom.codRestrict P f h = LieModuleHom.codRestrict P f_1 ⋯ |
List.SortedGT.reverse | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGT → l.reverse.SortedLT |
Std.ExtDTreeMap.Const.isSome_get?_iff_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{a : α}, (Std.ExtDTreeMap.Const.get? t a).isSome = true ↔ a ∈ t |
CategoryTheory.End.smul_left | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {r : (CategoryTheory.End X)ᵐᵒᵖ} {f : X ⟶ Y},
r • f = CategoryTheory.CategoryStruct.comp (MulOpposite.unop r) f |
StarAddMonoid.mk | Mathlib.Algebra.Star.Basic | {R : Type u} →
[inst : AddMonoid R] →
[toInvolutiveStar : InvolutiveStar R] → (∀ (r s : R), star (r + s) = star r + star s) → StarAddMonoid R |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._proof_6 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles._auto_1 → k + 1 + 2 ≤ n + 3 |
CategoryTheory.MonoOver.supLe._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasBinaryCoproducts C] {A : C}
(f g : CategoryTheory.MonoOver A), CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.pair f.obj.left g.obj.left) |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_498 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax |
Num.pos.injEq | Mathlib.Data.Num.Basic | ∀ (a a_1 : PosNum), (Num.pos a = Num.pos a_1) = (a = a_1) |
Function.FromTypes | Mathlib.Logic.Function.FromTypes | {n : ℕ} → (Fin n → Type u) → Type u → Type u |
_private.Lean.Server.FileWorker.ExampleHover.0.Lean.Server.FileWorker.Hover.RWState.output.injEq | Lean.Server.FileWorker.ExampleHover | ∀ (indent ticks indent_1 ticks_1 : ℕ),
(Lean.Server.FileWorker.Hover.RWState.output✝ indent ticks =
Lean.Server.FileWorker.Hover.RWState.output✝¹ indent_1 ticks_1) =
(indent = indent_1 ∧ ticks = ticks_1) |
Lean.Elab.Term.elabStateRefT | Lean.Elab.BuiltinNotation | Lean.Elab.Term.TermElab |
Real.instFloorRing | Mathlib.Data.Real.Archimedean | FloorRing ℝ |
Std.DTreeMap.Equiv.foldrM_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} {δ : Type w}
{m : Type w → Type w'} [Std.TransCmp cmp] [inst : Monad m] [LawfulMonad m] {f : (a : α) → β a → δ → m δ} {init : δ},
t₁.Equiv t₂ → Std.DTreeMap.foldrM f init t₁ = Std.DTreeMap.foldrM f init t₂ |
Subsemiring.mk'._proof_4 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (s : Set R) (sa : AddSubmonoid R), ↑sa = s → 0 ∈ s |
deriv_fun_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜},
DifferentiableAt 𝕜 f x → ∀ (n : ℕ), deriv (fun x => f x ^ n) x = ↑n * f x ^ (n - 1) * deriv f x |
Int.Cooper.mul_resolve_left_inv_le | Init.Data.Int.Cooper | ∀ {b q : ℤ} (a p k : ℤ), 0 < a → b * k + b * p ≤ a * q → a ∣ k + p → b * Int.Cooper.resolve_left_inv a p k ≤ q |
CategoryTheory.ProjectiveResolution.isoLeftDerivedToHomotopyCategoryObj | Mathlib.CategoryTheory.Abelian.LeftDerived | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[inst_2 : CategoryTheory.Abelian C] →
[inst_3 : CategoryTheory.HasProjectiveResolutions C] →
[inst_4 : CategoryTheory.Abelian D] →
{X : C} →
(P : CategoryTheory.ProjectiveResolution X) →
(F : CategoryTheory.Functor C D) →
[inst_5 : F.Additive] →
F.leftDerivedToHomotopyCategory.obj X ≅
((F.mapHomologicalComplex (ComplexShape.down ℕ)).comp
(HomotopyCategory.quotient D (ComplexShape.down ℕ))).obj
P.complex |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_toList_iff_getKey?_eq_some_and_get?_eq_some._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
monotoneOn_univ._simp_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β}, MonotoneOn f Set.univ = Monotone f |
CategoryTheory.Functor.IsDenseSubsite.sheafEquiv | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(G : CategoryTheory.Functor C D) →
(A : Type u_4) →
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] →
[inst_3 : CategoryTheory.Functor.IsDenseSubsite J K G] →
[(G.sheafPushforwardContinuous A J K).IsEquivalence] →
CategoryTheory.Sheaf J A ≌ CategoryTheory.Sheaf K A |
Std.DHashMap.mem_toArray_iff_get?_eq_some | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{v : β k}, ⟨k, v⟩ ∈ m.toArray ↔ m.get? k = some v |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mk.sizeOf_spec | Mathlib.Tactic.Linter.FlexibleLinter | ∀ (stx : Lean.Syntax) (ci : Lean.Elab.ContextInfo) (mctxBefore mctxAfter : Lean.MetavarContext)
(goalsTargetedBy goalsCreatedBy : List Lean.MVarId),
sizeOf
{ stx := stx, ci := ci, mctxBefore := mctxBefore, mctxAfter := mctxAfter, goalsTargetedBy := goalsTargetedBy,
goalsCreatedBy := goalsCreatedBy } =
1 + sizeOf stx + sizeOf ci + sizeOf mctxBefore + sizeOf mctxAfter + sizeOf goalsTargetedBy + sizeOf goalsCreatedBy |
smul_add_smul_le_smul_add_smul | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] [ExistsAddOfLE α]
[inst_4 : AddCommMonoid β] [inst_5 : PartialOrder β] [IsOrderedCancelAddMonoid β] [inst_7 : Module α β]
[PosSMulMono α β] {a₁ a₂ : α} {b₁ b₂ : β}, a₁ ≤ a₂ → b₁ ≤ b₂ → a₁ • b₂ + a₂ • b₁ ≤ a₁ • b₁ + a₂ • b₂ |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.collectMatchCondLhss._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.MatchCond | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Quaternion.coe_real_complex_mul | Mathlib.Analysis.Quaternion | ∀ (r : ℝ) (z : ℂ), r • ↑z = ↑r * ↑z |
IsLocalization.instForallPiUniv | Mathlib.RingTheory.Localization.Pi | ∀ {ι : Type u_1} (R : ι → Type u_2) (S : ι → Type u_3) [inst : (i : ι) → CommSemiring (R i)]
[inst_1 : (i : ι) → CommSemiring (S i)] [inst_2 : (i : ι) → Algebra (R i) (S i)] (M : (i : ι) → Submonoid (R i))
[∀ (i : ι), IsLocalization (M i) (S i)], IsLocalization (Submonoid.pi Set.univ M) ((i : ι) → S i) |
Homotopy.nullHomotopicMap'_f_eq_zero | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {k₀ : ι},
(∀ (l : ι), ¬c.Rel k₀ l) →
(∀ (l : ι), ¬c.Rel l k₀) → ∀ (h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)), (Homotopy.nullHomotopicMap' h).f k₀ = 0 |
IsLocalization.AtPrime.coe_orderIsoOfPrime_symm_apply_coe | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (I : Ideal R)
[hI : I.IsPrime] [inst_3 : IsLocalization.AtPrime S I] (a : { p // p.IsPrime ∧ p ≤ I }),
↑↑((RelIso.symm (IsLocalization.AtPrime.orderIsoOfPrime S I)) a) =
⋂ s,
⋂ (_ :
↑↑((OrderIso.setCongr (fun p => p.IsPrime ∧ Disjoint ↑I.primeCompl ↑p) (fun p => p.IsPrime ∧ p ≤ I) ⋯).symm a) ⊆
⇑(algebraMap R S) ⁻¹' ↑s),
↑s |
List.subset_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l ⊆ l.dedup |
Subring.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (S : Subring R) {a b : R},
a ∈ S.topologicalClosure.carrier → b ∈ S.topologicalClosure.carrier → a * b ∈ S.topologicalClosure.carrier |
USize.ofFin_mk | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < USize.size), USize.ofFin ⟨n, hn⟩ = USize.ofNatLT n hn |
LawfulBitraversable.binaturality' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {F G : Type u → Type u}
[inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F] [LawfulApplicative G]
(η : ApplicativeTransformation F G) {α α' β β' : Type u} (f : α → F β) (f' : α' → F β'),
(fun {α} => η.app α) ∘ bitraverse f f' = bitraverse ((fun {α} => η.app α) ∘ f) ((fun {α} => η.app α) ∘ f') |
Finsupp.fst_sumFinsuppAddEquivProdFinsupp | Mathlib.Data.Finsupp.Basic | ∀ {M : Type u_5} [inst : AddMonoid M] {α : Type u_12} {β : Type u_13} (f : α ⊕ β →₀ M) (x : α),
(Finsupp.sumFinsuppAddEquivProdFinsupp f).1 x = f (Sum.inl x) |
List.scanrM_map | Init.Data.List.Scan.Lemmas | ∀ {m : Type u_1 → Type u_2} {α₁ : Type u_3} {α₂ : Type u_4} {β : Type u_1} {init : β} [inst : Monad m] [LawfulMonad m]
{f : α₁ → α₂} {g : α₂ → β → m β} {as : List α₁},
List.scanrM g init (List.map f as) = List.scanrM (fun a b => g (f a) b) init as |
_private.Lean.Meta.Tactic.Grind.Order.Proof.0.Lean.Meta.Grind.Order.mkPropagateSelfEqFalseProofCore | Lean.Meta.Tactic.Grind.Order.Proof | Lean.Expr → Lean.Meta.Grind.Order.OrderM Lean.Expr |
ContinuousMap.instNonUnitalCommRingOfIsTopologicalRing._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalCommRing β] [IsTopologicalRing β], ContinuousSub β |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_8 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (curr : String.Pos.Raw),
¬len.byteIdx < curr.byteIdx → ¬len.byteIdx = curr.byteIdx + (len.byteIdx - curr.byteIdx) → False |
SeminormedAddCommGroup.toIsTopologicalAddGroup | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E], IsTopologicalAddGroup E |
_private.Lean.Elab.Tactic.Do.Spec.0.Lean.Elab.Tactic.Do.dischargeMGoal | Lean.Elab.Tactic.Do.Spec | {n : Type → Type u_1} →
[Monad n] → [MonadLiftT Lean.MetaM n] → Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.Name → Bool → n Lean.Expr |
FirstOrder.Language.BoundedFormula.realize_relabel._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} {m n : ℕ}
{φ : L.BoundedFormula α n} {g : α → β ⊕ Fin m} {v : β → M} {xs : Fin (m + n) → M},
(FirstOrder.Language.BoundedFormula.relabel g φ).Realize v xs =
φ.Realize (Sum.elim v (xs ∘ Fin.castAdd n) ∘ g) (xs ∘ Fin.natAdd m) |
List.map_zip_eq_zipWith | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α × β → γ} {l : List α} {l' : List β},
List.map f (l.zip l') = List.zipWith (Function.curry f) l l' |
Matrix.kroneckerTMulAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algebra S A]
[inst_10 : IsScalarTower R S A] [inst_11 : Fintype m] [inst_12 : DecidableEq m]
(x : Matrix (m × n) (m × n) (TensorProduct R A B)),
(Matrix.kroneckerTMulAlgEquiv m n R S A B).symm x = (kroneckerTMulLinearEquiv m m n n R S A B).symm x |
Lean.Widget.HighlightedMsgEmbed._sizeOf_4_eq | Lean.Server.FileWorker.WidgetRequests | ∀ (x : Array (Lean.Widget.TaggedText Lean.Widget.HighlightedMsgEmbed)),
Lean.Widget.HighlightedMsgEmbed._sizeOf_4 x = sizeOf x |
tendsto_fib_succ_div_fib_atTop | Mathlib.Analysis.SpecificLimits.Fibonacci | Filter.Tendsto (fun n => ↑(Nat.fib (n + 1)) / ↑(Nat.fib n)) Filter.atTop (nhds Real.goldenRatio) |
CommGroup.subgroupOrderIsoSubgroupMonoidHom.eq_1 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ (G : Type u_1) (M : Type u_2) [inst : CommGroup G] [inst_1 : Finite G] [inst_2 : CommMonoid M]
[hM : HasEnoughRootsOfUnity M (Monoid.exponent G)],
CommGroup.subgroupOrderIsoSubgroupMonoidHom G M =
{ toFun := fun H => OrderDual.toDual (MonoidHom.restrictHom H Mˣ).ker,
invFun := fun Φ =>
(CommGroup.monoidHomMonoidHomEquiv G M).mapSubgroup (MonoidHom.restrictHom (OrderDual.ofDual Φ) Mˣ).ker,
left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ } |
Nat.lcm_eq_mul_iff | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = m * n ↔ m = 0 ∨ n = 0 ∨ m.gcd n = 1 |
CategoryTheory.Limits.WidePushoutShape.struct._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePushoutShape J}, Z = Z |
CategoryTheory.Functor.copyObj.eq_1 | 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.copyObj obj e =
{ obj := obj,
map := fun {X Y} f =>
CategoryTheory.CategoryStruct.comp (e X).inv (CategoryTheory.CategoryStruct.comp (F.map f) (e Y).hom),
map_id := ⋯, map_comp := ⋯ } |
Basis.le_span'' | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [RankCondition R]
{ι : Type u_2} [inst_4 : Fintype ι] (b : Module.Basis ι R M) {w : Set M} [inst_5 : Fintype ↑w],
Submodule.span R w = ⊤ → Fintype.card ι ≤ Fintype.card ↑w |
Module.Baer.extensionOfMaxAdjoin._proof_2 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_2} [inst : Ring R] {Q : Type u_1} [inst_1 : AddCommGroup Q] [inst_2 : Module R Q] {M : Type u_3}
{N : Type u_4} [inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module R M] [inst_6 : Module R N]
(i : M →ₗ[R] N) (f : M →ₗ[R] Q) [inst_7 : Fact (Function.Injective ⇑i)] (h : Module.Baer R Q) (y : N) (r : R)
(a : ↥(Module.Baer.supExtensionOfMaxSingleton i f y)),
Module.Baer.ExtensionOfMaxAdjoin.extensionToFun i f h (r • a) =
(RingHom.id R) r • Module.Baer.ExtensionOfMaxAdjoin.extensionToFun i f h a |
Turing.EvalsTo.noConfusion | Mathlib.Computability.TMComputable | {P : Sort u} →
{σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} →
{b : Option σ} →
{t : Turing.EvalsTo f a b} →
{σ' : Type u_1} →
{f' : σ' → Option σ'} →
{a' : σ'} →
{b' : Option σ'} →
{t' : Turing.EvalsTo f' a' b'} →
σ = σ' → f ≍ f' → a ≍ a' → b ≍ b' → t ≍ t' → Turing.EvalsTo.noConfusionType P t t' |
List.Vector.get_replicate | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (i : Fin n), (List.Vector.replicate n a).get i = a |
Int.sign_eq_neg_one_iff_neg | Init.Data.Int.Order | ∀ {a : ℤ}, a.sign = -1 ↔ a < 0 |
ISize.toInt_inj | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, x.toInt = y.toInt ↔ x = y |
CategoryTheory.ChosenPullbacksAlong.isoInv_pullback_obj_left | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y X : C} (f : Y ≅ X) (Z : CategoryTheory.Over Y),
((CategoryTheory.ChosenPullbacksAlong.pullback f.inv).obj Z).left = Z.left |
Lean.Elab.Term.wrapAsyncAsSnapshot | Lean.Elab.Term.TermElabM | {α : Type} →
(α → Lean.Elab.TermElabM Unit) →
Option IO.CancelToken →
autoParam String Lean.Elab.Term.wrapAsyncAsSnapshot._auto_1 →
Lean.Elab.TermElabM (α → BaseIO Lean.Language.SnapshotTree) |
Mathlib.Tactic.Sat.Clause.expr | Mathlib.Tactic.Sat.FromLRAT | Mathlib.Tactic.Sat.Clause → Lean.Expr |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Translations.0.Option.getD.match_1.eq_2 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (x : α) → motive (some x)) (h_2 : Unit → motive none),
(match none with
| some x => h_1 x
| none => h_2 ()) =
h_2 () |
Real.Angle.abs_toReal_coe_eq_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : ℝ}, |(↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ Real.pi |
_private.Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy.0.HomotopicalAlgebra.FibrantObject.instHasQuotientWeakEquivalencesHomRel._simp_1 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C],
HomotopicalAlgebra.weakEquivalences C f = HomotopicalAlgebra.WeakEquivalence f |
Std.TreeSet.getD_max? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {km fallback : α},
t.max? = some km → t.getD km fallback = km |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Init.Tactics | Lean.Macro |
Std.Time.Modifier.ctorElimType | Std.Time.Format.Basic | {motive : Std.Time.Modifier → Sort u} → ℕ → Sort (max 1 u) |
Lean.IR.Decl.ctorElim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Decl → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Decl) → ctorIdx = t.ctorIdx → Lean.IR.Decl.ctorElimType ctorIdx → motive t |
instIsPredArchimedeanOrderDualOfIsSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α], IsPredArchimedean αᵒᵈ |
MulEquiv.val_piUnits_apply | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (f : ((i : ι) → M i)ˣ) (i : ι),
↑(MulEquiv.piUnits f i) = ↑f i |
Equiv.isCancelAdd | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Add β] [IsCancelAdd β], IsCancelAdd α |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.uniformContinuous_union.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : Set (α × α)) (a : (Set α × Set α) × Set α × Set α)
(motive : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U) → Prop)
(h : a ∈ entourageProd (hausdorffEntourage U) (hausdorffEntourage U)),
(∀ (h₁ : (a.1.1, a.2.1) ∈ hausdorffEntourage U) (h₂ : (a.1.2, a.2.2) ∈ hausdorffEntourage U), motive ⋯) → motive h |
_private.Batteries.Data.Array.Scan.0.Array.getElem_succ_scanl._proof_1_4 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {b : β} {as : Array α} {f : β → α → β},
i + 1 ≤ (List.scanl f b as.toList).length → i < (List.scanl f b as.toList).length |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.