name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ZMod.χ₈'_eq_χ₄_mul_χ₈ | Mathlib.NumberTheory.LegendreSymbol.ZModChar | ∀ (a : ZMod 8), ZMod.χ₈' a = ZMod.χ₄ a.cast * ZMod.χ₈ a |
Std.IterM.mk.inj | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} {internalState internalState_1 : α},
{ internalState := internalState } = { internalState := internalState_1 } → internalState = internalState_1 |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft'._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_3} (P : α → Sort u_2) (e : α ≃ β) (f : (a : α) → P a), (fun x => ⋯ ▸ f (e.symm (e x))) = f |
RingHom.FormallyUnramified.holdsForLocalization | Mathlib.RingTheory.RingHom.Unramified | RingHom.HoldsForLocalization fun {R S} [CommRing R] [CommRing S] => RingHom.FormallyUnramified |
leftCoset_mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {a : α}, a ∈ s → a • ↑s = ↑s |
Int8.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int8.minValue.toInt ≤ x.toInt |
_private.Init.Data.Char.Ordinal.0.Char.lt_iff_ofOrdinal_lt._simp_1_1 | Init.Data.Char.Ordinal | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) |
Continuous.homeoOfEquivCompactToT2 | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → [CompactSpace X] → [T2Space Y] → {f : X ≃ Y} → Continuous ⇑f → X ≃ₜ Y |
Filter.EventuallyEq.hasFDerivWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
f₀ =ᶠ[nhdsWithin x s] f₁ → f₀ x = f₁ x → (HasFDerivWithinAt f₀ f' s x ↔ HasFDerivWithinAt f₁ f' s x) |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_6 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → a ≤ i + 1 |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible._simp_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), (f.mapMatrix M).det = f M.det |
LaurentSeries.LaurentSeries_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (x : RatFunc K),
(LaurentSeries.LaurentSeriesPkg K).coe x = (algebraMap (RatFunc K) (LaurentSeries K)) x |
Holor.assocRight | Mathlib.Data.Holor | {α : Type} → {ds₁ ds₂ ds₃ : List ℕ} → Holor α (ds₁ ++ ds₂ ++ ds₃) → Holor α (ds₁ ++ (ds₂ ++ ds₃)) |
isStarProjection_iff' | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p : R} [inst : Mul R] [inst_1 : Star R], IsStarProjection p ↔ p * p = p ∧ star p = p |
_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower.match_1.eq_1 | Mathlib.Logic.Equiv.Multiset | ∀ (motive : List ℕ → ℕ → Sort u_1) (x : ℕ) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (m : ℕ) → (l : List ℕ) → (n : ℕ) → motive (m :: l) n),
(match [], x with
| [], x => h_1 x
| m :: l, n => h_2 m l n) =
h_1 x |
PresheafOfModules.epi_of_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} {f : M₁ ⟶ M₂},
(∀ ⦃X : Cᵒᵖ⦄, Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X))) → CategoryTheory.Epi f |
Interval.mulOneClass._proof_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s : Interval α),
WithBot.map₂ (fun x1 x2 => x1 * x2) (↑1) s = s |
AddCommMonoidWithOne.mk | Mathlib.Data.Nat.Cast.Defs | {R : Type u_2} → [toAddMonoidWithOne : AddMonoidWithOne R] → (∀ (a b : R), a + b = b + a) → AddCommMonoidWithOne R |
Lean.Parser.Term.liftMethod._regBuiltin.Lean.Parser.Term.liftMethod.parenthesizer_15 | Lean.Parser.Do | IO Unit |
VAdd.ctorIdx | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → VAdd G P → ℕ |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] {n : ℕ} {w₁ w₂ : Fin (n + 1) → R} {i : Fin (n + 1)}
(motive : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0 → Prop)
(x : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0),
(∀ (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i)) (h0 : w₁ i ≠ 0), motive ⋯) → motive x |
Std.DTreeMap.Internal.Impl.maxEntry?.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).maxEntry? = some ⟨k, v⟩ |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ}, i + 1 ≤ [].length → i < [].length |
Std.Roo._sizeOf_1 | Init.Data.Range.Polymorphic.PRange | {α : Type u} → [SizeOf α] → Std.Roo α → ℕ |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.total.match_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ (α : Type u_1) (β : Type u_2)
(motive :
((bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) →
Prop)
(x :
(bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β),
(∀
(f :
(bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) →
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β)
(hf : Function.Injective f), motive { toFun := f, inj' := hf }) →
motive x |
IsPrimitiveRoot.powerBasis_dim | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] (K : Type u) {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ : L} (hζ : IsPrimitiveRoot ζ n),
(IsPrimitiveRoot.powerBasis K hζ).dim = (minpoly K ζ).natDegree |
Pi.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | ∀ {ι : Type u_3} {α : Type u_1} {π : ι → Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α]
[inst_2 : (i : ι) → AddCommMonoid (π i)] [inst_3 : (i : ι) → PartialOrder (π i)]
[inst_4 : (i : ι) → SMulZeroClass α (π i)] [inst_5 : (i : ι) → CeilDiv α (π i)] (_a : α),
0 < _a → ∀ (_f _g : (i : ι) → π i), (∀ (a : ι), _f a ⌈/⌉ _a ≤ _g a) ↔ ∀ (a : ι), _f a ≤ (_a • _g) a |
Lean.Compiler.LCNF.Simp.CtorInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | SizeOf Lean.Compiler.LCNF.Simp.CtorInfo |
FormalMultilinearSeries.congr_simp | Mathlib.Analysis.Analytic.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd F] [inst_10 : ContinuousConstSMul 𝕜 F],
FormalMultilinearSeries 𝕜 E F = FormalMultilinearSeries 𝕜 E F |
Combinatorics.Line.ColorFocused.distinct_colors | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_5} {ι : Type u_6} {κ : Type u_7} {C : (ι → Option α) → κ} (self : Combinatorics.Line.ColorFocused C),
(Multiset.map Combinatorics.Line.AlmostMono.color self.lines).Nodup |
WittVector.IsPoly₂.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {h : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R → WittVector p R}
{f g : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hh : WittVector.IsPoly₂ p h]
[hf : WittVector.IsPoly p f] [hg : WittVector.IsPoly p g], WittVector.IsPoly₂ p fun x _Rcr x_1 y => h (f x_1) (g y) |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Lean.Name → Lean.Name → Lean.Exception → Lean.Meta.RefinedDiscrTree.ImportFailure✝ |
CategoryTheory.Adjunction.commShiftIso_hom_app_counit_app_shift_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShift D A] [inst_5 : F.CommShift A] [inst_6 : G.CommShift A] [adj.CommShift A] (a : A)
(Y : D) {Z : D} (h : (CategoryTheory.shiftFunctor D a).obj Y ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.commShiftIso (G.comp F) a).hom.app Y)
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D a).map (adj.counit.app Y)) h) =
CategoryTheory.CategoryStruct.comp (adj.counit.app ((CategoryTheory.shiftFunctor D a).obj Y)) h |
Topology.WithUpper | Mathlib.Topology.Order.LowerUpperTopology | Type u_3 → Type u_3 |
PFunctor.M.Agree'.recOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop} {a : ℕ}
{a_1 a_2 : F.M} (t : PFunctor.M.Agree' a a_1 a_2),
(∀ (x y : F.M), motive 0 x y ⋯) →
(∀ {n : ℕ} {a : F.A} (x y : F.B a → F.M) {x' y' : F.M} (a_3 : x' = PFunctor.M.mk ⟨a, x⟩)
(a_4 : y' = PFunctor.M.mk ⟨a, y⟩) (a_5 : ∀ (i : F.B a), PFunctor.M.Agree' n (x i) (y i)),
(∀ (i : F.B a), motive n (x i) (y i) ⋯) → motive n.succ x' y' ⋯) →
motive a a_1 a_2 t |
Option.merge_none_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {f : α → α → α} {b : Option α}, Option.merge f none b = b |
CategoryTheory.Pi.instBraidedForallEval._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_3} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)]
(i : I) (X Y : (i : I) → C i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y)
((CategoryTheory.Pi.eval C i).map (β_ X Y).hom) =
CategoryTheory.CategoryStruct.comp
(β_ ((CategoryTheory.Pi.eval C i).obj X) ((CategoryTheory.Pi.eval C i).obj Y)).hom
(CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) Y X) |
Aesop.BaseRuleSet.mk.injEq | Aesop.RuleSet | ∀ (normRules : Aesop.Index Aesop.NormRuleInfo) (unsafeRules : Aesop.Index Aesop.UnsafeRuleInfo)
(safeRules : Aesop.Index Aesop.SafeRuleInfo) (unfoldRules : Lean.PHashMap Lean.Name (Option Lean.Name))
(forwardRules : Aesop.ForwardIndex) (forwardRuleNames : Lean.PHashSet Aesop.RuleName)
(rulePatterns : Aesop.RulePatternIndex) (erased : Lean.PHashSet Aesop.RuleName)
(ruleNames : Lean.PHashMap Lean.Name (Aesop.UnorderedArraySet Aesop.RuleName))
(normRules_1 : Aesop.Index Aesop.NormRuleInfo) (unsafeRules_1 : Aesop.Index Aesop.UnsafeRuleInfo)
(safeRules_1 : Aesop.Index Aesop.SafeRuleInfo) (unfoldRules_1 : Lean.PHashMap Lean.Name (Option Lean.Name))
(forwardRules_1 : Aesop.ForwardIndex) (forwardRuleNames_1 : Lean.PHashSet Aesop.RuleName)
(rulePatterns_1 : Aesop.RulePatternIndex) (erased_1 : Lean.PHashSet Aesop.RuleName)
(ruleNames_1 : Lean.PHashMap Lean.Name (Aesop.UnorderedArraySet Aesop.RuleName)),
({ normRules := normRules, unsafeRules := unsafeRules, safeRules := safeRules, unfoldRules := unfoldRules,
forwardRules := forwardRules, forwardRuleNames := forwardRuleNames, rulePatterns := rulePatterns,
erased := erased, ruleNames := ruleNames } =
{ normRules := normRules_1, unsafeRules := unsafeRules_1, safeRules := safeRules_1, unfoldRules := unfoldRules_1,
forwardRules := forwardRules_1, forwardRuleNames := forwardRuleNames_1, rulePatterns := rulePatterns_1,
erased := erased_1, ruleNames := ruleNames_1 }) =
(normRules = normRules_1 ∧
unsafeRules = unsafeRules_1 ∧
safeRules = safeRules_1 ∧
unfoldRules = unfoldRules_1 ∧
forwardRules = forwardRules_1 ∧
forwardRuleNames = forwardRuleNames_1 ∧
rulePatterns = rulePatterns_1 ∧ erased = erased_1 ∧ ruleNames = ruleNames_1) |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.exprToMatcher.match_12 | Mathlib.Util.Notation3 | (motive : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term → Sort u_1) →
(__discr : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term) →
((keys : List Mathlib.Notation3.DelabKey) → (matchF : Lean.TSyntax `term) → motive (keys, matchF)) → motive __discr |
Std.Time.Month.instLawfulEqOrdOffset | Std.Time.Date.Unit.Month | Std.LawfulEqOrd Std.Time.Month.Offset |
BitVec.instRxcIsAlwaysFinite | Init.Data.Range.Polymorphic.BitVec | ∀ {n : ℕ}, Std.Rxc.IsAlwaysFinite (BitVec n) |
BddOrd.Iso.mk | Mathlib.Order.Category.BddOrd | {α β : BddOrd} → ↑α.toPartOrd ≃o ↑β.toPartOrd → (α ≅ β) |
_private.Mathlib.RingTheory.Smooth.StandardSmoothCotangent.0.Algebra.SubmersivePresentation.sectionCotangent_zero_of_notMem_range._proof_1_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_3} {S : Type u_4} {ι : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (i : ι),
(¬∀ (i_1 : σ), (if i = P.map i_1 then 1 else 0) = 0) → i ∈ Set.range P.map |
IsDiscrete.mono | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsDiscrete s → t ⊆ s → IsDiscrete t |
_private.Std.Time.Date.Basic.0.Std.Time.Millisecond.Offset.ofDays._proof_1 | Std.Time.Date.Basic | 86400 / ↑86400000 = 1 / 1000 |
Option.bind_eq_none' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β},
o.bind f = none ↔ ∀ (b : β) (a : α), o = some a → f a ≠ some b |
_private.Mathlib.Data.Real.Archimedean.0.Real.exists_isLUB.match_1_4 | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ} (f : ℕ → ℤ) (n : ℕ) (motive : (∃ y ∈ s, ↑(↑(f n) / ↑n) ≤ y) → Prop) (x : ∃ y ∈ s, ↑(↑(f n) / ↑n) ≤ y),
(∀ (x : ℝ) (xS : x ∈ s) (hx : ↑(↑(f n) / ↑n) ≤ x), motive ⋯) → motive x |
MvQPF.Comp | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} → (TypeVec.{u} n → Type u_1) → (Fin2 n → TypeVec.{u} m → Type u) → TypeVec.{u} m → Type u_1 |
AddMonoidHom.toMultiplicative | Mathlib.Algebra.Group.TypeTags.Hom | {α : Type u_3} →
{β : Type u_4} →
[inst : AddZeroClass α] → [inst_1 : AddZeroClass β] → (α →+ β) ≃ (Multiplicative α →* Multiplicative β) |
CategoryTheory.MonoidalCategory.DayConvolution.unit_naturality | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(F G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G] {x x' y y' : C}
(f : x ⟶ x') (g : y ⟶ y'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom (F.map f) (G.map g))
((CategoryTheory.MonoidalCategory.DayConvolution.unit F G).app (x', y')) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategory.DayConvolution.unit F G).app (x, y))
((CategoryTheory.MonoidalCategory.DayConvolution.convolution F G).map
(CategoryTheory.MonoidalCategoryStruct.tensorHom f g)) |
CategoryTheory.BasedFunctor.mk | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{𝒳 : CategoryTheory.BasedCategory 𝒮} →
{𝒴 : CategoryTheory.BasedCategory 𝒮} →
(toFunctor : CategoryTheory.Functor 𝒳.obj 𝒴.obj) →
autoParam (toFunctor.comp 𝒴.p = 𝒳.p) CategoryTheory.BasedFunctor.w._autoParam →
CategoryTheory.BasedFunctor 𝒳 𝒴 |
ExpChar.congr | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p : ℕ} (q : ℕ) [hq : ExpChar R q], q = p → ExpChar R p |
Std.HashMap.getElem_filterMap'._proof_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : LawfulBEq α]
{f : α → β → Option γ} {k : α} {h : k ∈ Std.HashMap.filterMap f m}, (f k m[k]).isSome = true |
CategoryTheory.Enriched.Functor.functorHom_whiskerLeft_natTransEquiv_symm_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(K L : CategoryTheory.Functor C D) (X : C) (f : L ⟶ L)
(x :
CategoryTheory.MonoidalCategoryStruct.tensorObj ((K.functorHom L).obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (Type (max (max u v) v')))),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (K.functorHom L) (CategoryTheory.Functor.natTransEquiv.symm f)).app
X x =
(x.1, CategoryTheory.Functor.HomObj.ofNatTrans f) |
String.utf8Len_le_of_infix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+: cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ |
FiniteAddGrp.of.eq_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | ∀ (G : Type u) [inst : AddGroup G] [inst_1 : Finite G],
FiniteAddGrp.of G = { toAddGrp := AddGrpCat.of G, isFinite := inst_1 } |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.mem_part_ofSetSetoid_iff_rel._simp_1_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a b : α},
(a ∈ P.part b) = ∃ p ∈ P.parts, a ∈ p ∧ b ∈ p |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.negThm?._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Option (Option Lean.Expr) |
MonoidHom.inr_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : MulOneClass M] [inst_1 : MulOneClass N] (y : N), (MonoidHom.inr M N) y = (1, y) |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs : Lean.Meta.Grind.Arith.Linear.LinExpr}
{c_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c lhs =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c_1 lhs_1 →
c = c_1 ∧ lhs = lhs_1 |
Std.DTreeMap.Internal.Impl.Equiv.minEntry_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → ∀ (h : t₁.Equiv t₂) {he : t₁.isEmpty = false}, t₁.minEntry he = t₂.minEntry ⋯ |
constFormalMultilinearSeries.match_1 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((x : ℕ) → motive x) → motive x |
Lean.Doc.Block.rec_5 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1} →
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_7 : List (Lean.Doc.Block i b) → Sort u_1} →
{motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) → Sort u_1} →
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) → Sort u_1} →
((contents : Array (Lean.Doc.Inline i)) → motive_1 (Lean.Doc.Block.para contents)) →
((content : String) → motive_1 (Lean.Doc.Block.code content)) →
((items : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_2 items → motive_1 (Lean.Doc.Block.ul items)) →
((start : ℤ) →
(items : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_2 items → motive_1 (Lean.Doc.Block.ol start items)) →
((items : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
motive_3 items → motive_1 (Lean.Doc.Block.dl items)) →
((items : Array (Lean.Doc.Block i b)) →
motive_4 items → motive_1 (Lean.Doc.Block.blockquote items)) →
((content : Array (Lean.Doc.Block i b)) →
motive_4 content → motive_1 (Lean.Doc.Block.concat content)) →
((container : b) →
(content : Array (Lean.Doc.Block i b)) →
motive_4 content → motive_1 (Lean.Doc.Block.other container content)) →
((toList : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_5 toList → motive_2 { toList := toList }) →
((toList : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
motive_6 toList → motive_3 { toList := toList }) →
((toList : List (Lean.Doc.Block i b)) →
motive_7 toList → motive_4 { toList := toList }) →
motive_5 [] →
((head : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
(tail : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_8 head → motive_5 tail → motive_5 (head :: tail)) →
motive_6 [] →
((head : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) →
(tail :
List
(Lean.Doc.DescItem (Lean.Doc.Inline i)
(Lean.Doc.Block i b))) →
motive_9 head → motive_6 tail → motive_6 (head :: tail)) →
motive_7 [] →
((head : Lean.Doc.Block i b) →
(tail : List (Lean.Doc.Block i b)) →
motive_1 head → motive_7 tail → motive_7 (head :: tail)) →
((contents : Array (Lean.Doc.Block i b)) →
motive_4 contents → motive_8 { contents := contents }) →
((term : Array (Lean.Doc.Inline i)) →
(desc : Array (Lean.Doc.Block i b)) →
motive_4 desc →
motive_9 { term := term, desc := desc }) →
(t :
List
(Lean.Doc.DescItem (Lean.Doc.Inline i)
(Lean.Doc.Block i b))) →
motive_6 t |
_private.Lean.Server.InfoUtils.0.Lean.Elab.Info.type?._sparseCasesOn_1 | Lean.Server.InfoUtils | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) →
((i : Lean.Elab.FieldInfo) → motive (Lean.Elab.Info.ofFieldInfo i)) →
((i : Lean.Elab.DelabTermInfo) → motive (Lean.Elab.Info.ofDelabTermInfo i)) →
(Nat.hasNotBit 8322 t.ctorIdx → motive t) → motive t |
Std.DTreeMap.getKey!_eq_get!_getKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {a : α}, t.getKey! a = (t.getKey? a).get! |
NormedGroup.toENormedMonoid._proof_4 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {F : Type u_1} [inst : NormedGroup F] (x y : F), ‖x * y‖ₑ ≤ ‖x‖ₑ + ‖y‖ₑ |
IsLocalization.IsInteger.eq_1 | Mathlib.RingTheory.Localization.Rat | ∀ (R : Type u_1) [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a : S),
IsLocalization.IsInteger R a = (a ∈ (algebraMap R S).rangeS) |
CategoryTheory.Limits.equalizerSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerSubobjectIso f g).hom
(CategoryTheory.Limits.equalizer.ι f g) =
(CategoryTheory.Limits.equalizerSubobject f g).arrow |
MeasureTheory.AECover.integral_tendsto_of_countably_generated | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → E},
MeasureTheory.Integrable f μ → Filter.Tendsto (fun i => ∫ (x : α) in φ i, f x ∂μ) l (nhds (∫ (x : α), f x ∂μ)) |
ScottContinuous.comp | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{f : α → β} {g : β → γ}, ScottContinuous f → ScottContinuous g → ScottContinuous (g ∘ f) |
FiniteField.exists_nonsquare | Mathlib.FieldTheory.Finite.Basic | ∀ {F : Type u_3} [inst : Field F] [Finite F], ringChar F ≠ 2 → ∃ a, ¬IsSquare a |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.toString.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (motive : (x : Substring.Raw) → Substring.Raw.ValidFor l m r x → Prop) (x : Substring.Raw)
(x_1 : Substring.Raw.ValidFor l m r x),
(∀ (a : Unit),
motive
{ str := String.ofList (l ++ m ++ r), startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf8Len l + String.utf8Len m } }
⋯) →
motive x x_1 |
Lean.Meta.ArgsPacker.noConfusionType | Lean.Meta.ArgsPacker.Basic | Sort u → Lean.Meta.ArgsPacker → Lean.Meta.ArgsPacker → Sort u |
Interval.recBotCoe | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : LE α] → {C : Interval α → Sort u_6} → C ⊥ → ((a : NonemptyInterval α) → C ↑a) → (n : Interval α) → C n |
Fin.univ_def | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ), Finset.univ = { val := ↑(List.finRange n), nodup := ⋯ } |
EuclideanGeometry.Sphere.isIntTangent_self_iff | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [Nontrivial V] {s : EuclideanGeometry.Sphere P}, s.IsIntTangent s ↔ 0 ≤ s.radius |
Lean.Meta.reduceBoolNativeUnsafe | Lean.Meta.WHNF | Lean.Name → Lean.MetaM Bool |
Lean.Elab.Command.Scope.levelNames._default | Lean.Elab.Command.Scope | List Lean.Name |
Polynomial.div_tendsto_atBot_zero_iff_degree_lt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q ≠ 0 →
(Filter.Tendsto (fun x => Polynomial.eval x P / Polynomial.eval x Q) Filter.atBot (nhds 0) ↔ P.degree < Q.degree) |
CategoryTheory.Deterministic | Mathlib.CategoryTheory.CopyDiscardCategory.Deterministic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [CategoryTheory.CopyDiscardCategory C] → {X Y : C} → (X ⟶ Y) → Prop |
_private.Batteries.Data.RBMap.Depth.0.Batteries.RBNode.Balanced.le_size.match_1_7 | Batteries.Data.RBMap.Depth | ∀ {α : Type u_1},
let funType_1 := fun {t} {c} {n} x => 2 ^ Batteries.RBNode.depthLB c n ≤ t.size + 1;
∀
(motive :
(n : ℕ) →
(c : Batteries.RBColor) →
(t : Batteries.RBNode α) → (x : t.Balanced c n) → Batteries.RBNode.Balanced.below x → Prop)
(n : ℕ) (c : Batteries.RBColor) (t : Batteries.RBNode α) (x : t.Balanced c n)
(below : Batteries.RBNode.Balanced.below x),
(∀ (a : Unit), motive 0 Batteries.RBColor.black Batteries.RBNode.nil ⋯ ⋯) →
(∀ (n : ℕ) (x y : Batteries.RBNode α) (v : α) (hl : x.Balanced Batteries.RBColor.black n)
(hr : y.Balanced Batteries.RBColor.black n) (ih : Batteries.RBNode.Balanced.below hl) (a_ih : funType_1 hl)
(ih_1 : Batteries.RBNode.Balanced.below hr) (a_ih_1 : funType_1 hr),
motive n Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red x v y) ⋯ ⋯) →
(∀ (x : Batteries.RBNode α) (c₁ : Batteries.RBColor) (n : ℕ) (y : Batteries.RBNode α) (c₂ : Batteries.RBColor)
(v : α) (hl : x.Balanced c₁ n) (hr : y.Balanced c₂ n) (ih : Batteries.RBNode.Balanced.below hl)
(a_ih : funType_1 hl) (ih_1 : Batteries.RBNode.Balanced.below hr) (a_ih_1 : funType_1 hr),
motive (n + 1) Batteries.RBColor.black (Batteries.RBNode.node Batteries.RBColor.black x v y) ⋯ ⋯) →
motive n c t x below |
OrderIso.map_ciSup_set_of_directedOn | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompletePartialOrderSup α]
[inst_1 : ConditionallyCompletePartialOrderSup β] (e : α ≃o β) {s : Set γ} {f : γ → α},
DirectedOn (fun x1 x2 => x1 ≤ x2) (f '' s) → BddAbove (f '' s) → s.Nonempty → e (⨆ i, f ↑i) = ⨆ i, e (f ↑i) |
Subgroup.exists_pow_mem_of_index_ne_zero | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.index ≠ 0 → ∀ (a : G), ∃ n, 0 < n ∧ n ≤ H.index ∧ a ^ n ∈ H |
CategoryTheory.ShortComplex.SnakeInput.mono_v₀₁_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Mono S.v₀₁.τ₂ |
Nat.fact_prime_two | Mathlib.Data.Nat.Prime.Defs | Fact (Nat.Prime 2) |
_private.Mathlib.Topology.LocallyFinsupp.0.Function.locallyFinsuppWithin.addSubgroup._simp_1 | Mathlib.Topology.LocallyFinsupp | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {s : Set ι},
(Function.support f ⊆ s) = ∀ (x : ι), f x ≠ 0 → x ∈ s |
DirichletCharacter.isPrimitive_one_level_one | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R], DirichletCharacter.IsPrimitive 1 |
Std.ExtDTreeMap.le_minKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (∀ (k' : α), t.minKey? = some k' → (cmp k k').isLE = true) ↔ ∀ k' ∈ t, (cmp k k').isLE = true |
lp.singleAddMonoidHom | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} →
[inst : (i : α) → NormedAddCommGroup (E i)] → [DecidableEq α] → (p : ENNReal) → (i : α) → E i →+ ↥(lp E p) |
UpperSet.coe_zero | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α], ↑0 = Set.Ici 0 |
isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A] [inst_3 : Module ℂ A]
[inst_4 : IsScalarTower ℂ A A] [inst_5 : SMulCommClass ℂ A A] [NonUnitalContinuousFunctionalCalculus ℂ A IsStarNormal]
{a : A}, IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a ⇑Complex.reCLM |
ProbabilityTheory.lintegral_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
∫⁻ (a : α), ENNReal.ofReal (↑(ProbabilityTheory.condCDF ρ a) x) ∂ρ.fst = ρ (Set.univ ×ˢ Set.Iic x) |
Filter.boundedFilterSubalgebra._proof_2 | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ (𝕜 : Type u_3) {α : Type u_1} {β : Type u_2} [inst : SeminormedCommRing 𝕜] [inst_1 : SeminormedRing β]
[inst_2 : Algebra 𝕜 β] [inst_3 : IsBoundedSMul 𝕜 β] (l : Filter α) (f g : α → β),
f ∈ Filter.boundedFilterSubmodule 𝕜 l →
g ∈ Filter.boundedFilterSubmodule 𝕜 l → f * g ∈ Filter.boundedFilterSubmodule 𝕜 l |
_private.Init.Data.SInt.Lemmas.0.ISize.ofNat_mul._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.ofNat n = ISize.ofInt ↑n |
TrivSqZeroExt.snd_mul | Mathlib.Algebra.TrivSqZeroExt | ∀ {R : Type u} {M : Type v} [inst : Mul R] [inst_1 : Add M] [inst_2 : SMul R M] [inst_3 : SMul Rᵐᵒᵖ M]
(x₁ x₂ : TrivSqZeroExt R M), (x₁ * x₂).snd = x₁.fst • x₂.snd + MulOpposite.op x₂.fst • x₁.snd |
AddSubgroup.nontrivial_iff_exists_ne_zero | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0 |
ByteArray.Iterator.casesOn | Init.Data.ByteArray.Basic | {motive : ByteArray.Iterator → Sort u} →
(t : ByteArray.Iterator) → ((array : ByteArray) → (idx : ℕ) → motive { array := array, idx := idx }) → motive t |
BitVec.hash._unary.eq_def | Init.Data.BitVec.Basic | ∀ (_x : (n : ℕ) ×' BitVec n),
BitVec.hash._unary _x =
PSigma.casesOn _x fun n bv =>
if n ≤ 64 then (↑bv.toFin).toUInt64
else mixHash (↑bv.toFin).toUInt64 (BitVec.hash._unary ⟨n - 64, BitVec.setWidth (n - 64) (bv >>> 64)⟩) |
Std.DTreeMap.Internal.Unit.RoiSliceData.mk | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Std.Roi α → Std.DTreeMap.Internal.Unit.RoiSliceData α |
Complex.norm_ofNat | Mathlib.Analysis.Complex.Norm | ∀ (n : ℕ) [inst : n.AtLeastTwo], ‖OfNat.ofNat n‖ = OfNat.ofNat n |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.