name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
conformalAt_id
|
Mathlib.Analysis.Calculus.Conformal.NormedSpace
|
β {X : Type u_1} [inst : NormedAddCommGroup X] [inst_1 : NormedSpace β X] (x : X), ConformalAt id x
|
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.runPass.match_5
|
Mathlib.Tactic.TacticAnalysis
|
(config : Mathlib.TacticAnalysis.ComplexConfig) β
(motive : Mathlib.TacticAnalysis.TriggerCondition config.ctx β Sort u_1) β
(x : Mathlib.TacticAnalysis.TriggerCondition config.ctx) β
((ctx : config.ctx) β motive (Mathlib.TacticAnalysis.TriggerCondition.accept ctx)) β
((x : Mathlib.TacticAnalysis.TriggerCondition config.ctx) β motive x) β motive x
|
DirectSum.GradeZero.semiring._proof_3
|
Mathlib.Algebra.DirectSum.Ring
|
β {ΞΉ : Type u_1} [inst : DecidableEq ΞΉ] (A : ΞΉ β Type u_2) [inst_1 : (i : ΞΉ) β AddCommMonoid (A i)]
[inst_2 : AddMonoid ΞΉ] [inst_3 : DirectSum.GSemiring A], (DirectSum.of A 0) 1 = 1
|
Aesop.RuleResult.isSuccessful
|
Aesop.Search.Expansion
|
Aesop.RuleResult β Bool
|
MulChar.instMulCharClass
|
Mathlib.NumberTheory.MulChar.Basic
|
β {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'],
MulCharClass (MulChar R R') R R'
|
Pi.seminormedRing._proof_7
|
Mathlib.Analysis.Normed.Ring.Lemmas
|
β {ΞΉ : Type u_1} {R : ΞΉ β Type u_2} [inst : (i : ΞΉ) β SeminormedRing (R i)] (a : (i : ΞΉ) β R i), 1 * a = a
|
FractionalIdeal.count._proof_2
|
Mathlib.RingTheory.DedekindDomain.Factorization
|
β {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (I : FractionalIdeal (nonZeroDivisors R) K),
β aI,
Classical.choose β― β 0 β§
I = FractionalIdeal.spanSingleton (nonZeroDivisors R) ((algebraMap R K) (Classical.choose β―))β»ΒΉ * βaI
|
Nat.Ico_zero_eq_range
|
Mathlib.Order.Interval.Finset.Nat
|
Finset.Ico 0 = Finset.range
|
Vector.finIdxOf?
|
Init.Data.Vector.Basic
|
{Ξ± : Type u_1} β {n : β} β [BEq Ξ±] β Vector Ξ± n β Ξ± β Option (Fin n)
|
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.flatten.match_1.splitter
|
Mathlib.Data.WSeq.Basic
|
{Ξ± : Type u_1} β
(motive : Stream'.WSeq Ξ± β Computation (Stream'.WSeq Ξ±) β Sort u_2) β
(x : Stream'.WSeq Ξ± β Computation (Stream'.WSeq Ξ±)) β
((s : Stream'.WSeq Ξ±) β motive (Sum.inl s)) β
((c' : Computation (Stream'.WSeq Ξ±)) β motive (Sum.inr c')) β motive x
|
Batteries.RBSet.empty
|
Batteries.Data.RBMap.Basic
|
{Ξ± : Type u_1} β {cmp : Ξ± β Ξ± β Ordering} β Batteries.RBSet Ξ± cmp
|
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Submonoid.LocalizationMap.isCancelMul.match_1_2
|
Mathlib.GroupTheory.MonoidLocalization.Basic
|
β {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) (n : N) (motive : (β x, n * f βx.2 = f x.1) β Prop) (x : β x, n * f βx.2 = f x.1),
(β (ms : M Γ β₯S) (eq : n * f βms.2 = f ms.1), motive β―) β motive x
|
CategoryTheory.Limits.HasBinaryProduct
|
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts
|
{C : Type u} β [CategoryTheory.Category.{v, u} C] β C β C β Prop
|
Array.isEmpty.eq_1
|
Init.Data.List.ToArray
|
β {Ξ± : Type u} (xs : Array Ξ±), xs.isEmpty = decide (xs.size = 0)
|
Std.instLawfulOrderLeftLeaningMaxOfIsLinearOrderOfLawfulOrderSup
|
Init.Data.Order.Lemmas
|
β {Ξ± : Type u} [inst : LE Ξ±] [inst_1 : Max Ξ±] [Std.IsLinearOrder Ξ±] [Std.LawfulOrderSup Ξ±],
Std.LawfulOrderLeftLeaningMax Ξ±
|
TrivSqZeroExt.snd
|
Mathlib.Algebra.TrivSqZeroExt
|
{R : Type u} β {M : Type v} β TrivSqZeroExt R M β M
|
AbsoluteValue.eq_trivial_of_isEquiv_trivial
|
Mathlib.Analysis.AbsoluteValue.Equivalence
|
β {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Semifield S] [inst_2 : LinearOrder S]
[inst_3 : DecidablePred fun x => x = 0] [inst_4 : NoZeroDivisors R] [inst_5 : IsStrictOrderedRing S]
{f : AbsoluteValue R S}, f.IsEquiv AbsoluteValue.trivial β f = AbsoluteValue.trivial
|
CauSeq.equiv
|
Mathlib.Algebra.Order.CauSeq.Basic
|
{Ξ± : Type u_1} β
{Ξ² : Type u_2} β
[inst : Field Ξ±] β
[inst_1 : LinearOrder Ξ±] β
[inst_2 : IsStrictOrderedRing Ξ±] β
[inst_3 : Ring Ξ²] β {abv : Ξ² β Ξ±} β [IsAbsoluteValue abv] β Setoid (CauSeq Ξ² abv)
|
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_cons_of_ne._proof_1_2
|
Mathlib.Data.Finset.Basic
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {a b : Ξ±} {s : Finset Ξ±} (ha : a β s),
a β b β (Finset.cons a s ha).erase b = Finset.cons a (s.erase b) β―
|
IsIntegral.mem_range_algebraMap_of_minpoly_splits
|
Mathlib.RingTheory.Adjoin.Field
|
β {R : Type u_1} {K : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra R K] {x : L} [inst_4 : Algebra R L] [inst_5 : Algebra K L] [IsScalarTower R K L],
IsIntegral R x β (Polynomial.map (algebraMap R K) (minpoly R x)).Splits β x β (algebraMap K L).range
|
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balance2.match_1.splitter._sparseCasesOn_5
|
Batteries.Data.RBMap.Lemmas
|
{motive : Batteries.RBColor β Sort u} β
(t : Batteries.RBColor) β motive Batteries.RBColor.red β (Nat.hasNotBit 1 t.ctorIdx β motive t) β motive t
|
NoBotOrder.casesOn
|
Mathlib.Order.Max
|
{Ξ± : Type u_3} β
[inst : LE Ξ±] β
{motive : NoBotOrder Ξ± β Sort u} β
(t : NoBotOrder Ξ±) β ((exists_not_ge : β (a : Ξ±), β b, Β¬a β€ b) β motive β―) β motive t
|
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.injOn_setOf_mem_Icc_setOf_lower_eq._simp_1_2
|
Mathlib.Analysis.BoxIntegral.Partition.Basic
|
β {Ξ± : Type u} {a : Ξ±} {p : Ξ± β Prop}, (a β {x | p x}) = p a
|
_private.Init.Data.Int.Gcd.0.Int.gcd_eq_natAbs_right_iff_dvd._simp_1_1
|
Init.Data.Int.Gcd
|
β {n m : β}, (n.gcd m = m) = (m β£ n)
|
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff'._simp_1_1
|
Mathlib.Analysis.InnerProductSpace.Positive
|
β {π : Type u_1} {E : Type u_2} [inst : RCLike π] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace π E]
[inst_3 : CompleteSpace E] {A : E βL[π] E}, IsSelfAdjoint A = (βA).IsSymmetric
|
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.parallelPair.match_1.eq_2
|
Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
|
β (motive : CategoryTheory.Limits.WalkingParallelPair β Sort u_1)
(h_1 : Unit β motive CategoryTheory.Limits.WalkingParallelPair.zero)
(h_2 : Unit β motive CategoryTheory.Limits.WalkingParallelPair.one),
(match CategoryTheory.Limits.WalkingParallelPair.one with
| CategoryTheory.Limits.WalkingParallelPair.zero => h_1 ()
| CategoryTheory.Limits.WalkingParallelPair.one => h_2 ()) =
h_2 ()
|
Lean.Lsp.FoldingRangeKind.ctorElim
|
Lean.Data.Lsp.LanguageFeatures
|
{motive : Lean.Lsp.FoldingRangeKind β Sort u} β
(ctorIdx : β) β
(t : Lean.Lsp.FoldingRangeKind) β ctorIdx = t.ctorIdx β Lean.Lsp.FoldingRangeKind.ctorElimType ctorIdx β motive t
|
Char.reduceIsUpper._regBuiltin.Char.reduceIsUpper.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.2972409855._hygCtx._hyg.17
|
Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char
|
IO Unit
|
Std.Internal.List.Const.getValue_alterKey_self._proof_1
|
Std.Data.Internal.List.Associative
|
β {Ξ± : Type u_2} [inst : BEq Ξ±] {Ξ² : Type u_1} [EquivBEq Ξ±] (k : Ξ±) (f : Option Ξ² β Option Ξ²) (l : List ((_ : Ξ±) Γ Ξ²)),
Std.Internal.List.DistinctKeys l β
Std.Internal.List.containsKey k (Std.Internal.List.Const.alterKey k f l) = true β
(if true = true then (f (Std.Internal.List.getValue? k l)).isSome else Std.Internal.List.containsKey k l) = true
|
_private.Init.Data.Array.Basic.0.Array.allDiffAux._proof_1
|
Init.Data.Array.Basic
|
β {Ξ± : Type u_1} (as : Array Ξ±), β i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i
|
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxo.LawfulHasSize.of_closed._simp_6
|
Init.Data.Range.Polymorphic.Instances
|
β {Ξ± : Type u} [inst : LE Ξ±] [inst_1 : Std.PRange.UpwardEnumerable Ξ±] [inst_2 : Std.Rxc.HasSize Ξ±]
[Std.Rxc.LawfulHasSize Ξ±] {lo hi : Ξ±}, (0 < Std.Rxc.HasSize.size lo hi) = (lo β€ hi)
|
CoxeterSystem.exists_reduced_word
|
Mathlib.GroupTheory.Coxeter.Length
|
β {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w : W),
β Ο, Ο.length = cs.length w β§ w = cs.wordProd Ο
|
Submodule.spanRank_toENat_eq_iInf_finset_card
|
Mathlib.Algebra.Module.SpanRank
|
β {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.toENat p.spanRank = β¨
s, β(βs).card
|
ProofWidgets.Component.mk.sizeOf_spec
|
ProofWidgets.Component.Basic
|
β {Props : Type} [inst : SizeOf Props] (toModule : Lean.Widget.Module) (Β«exportΒ» : String),
sizeOf { toModule := toModule, Β«exportΒ» := Β«exportΒ» } = 1 + sizeOf toModule + sizeOf Β«exportΒ»
|
Lean.Meta.Grind.AlphaShareCommon.State.set._default
|
Lean.Meta.Tactic.Grind.AlphaShareCommon
|
Lean.PHashSet Lean.Meta.Grind.AlphaKey
|
Int64.ofNat_add
|
Init.Data.SInt.Lemmas
|
β (a b : β), Int64.ofNat (a + b) = Int64.ofNat a + Int64.ofNat b
|
IsSolvable
|
Mathlib.GroupTheory.Solvable
|
(G : Type u_1) β [Group G] β Prop
|
CategoryTheory.instFullExactFunctorFunctorForget
|
Mathlib.CategoryTheory.Limits.ExactFunctor
|
β (C : Type uβ) [inst : CategoryTheory.Category.{vβ, uβ} C] (D : Type uβ) [inst_1 : CategoryTheory.Category.{vβ, uβ} D],
(CategoryTheory.ExactFunctor.forget C D).Full
|
AddSubgroup.relIndex_eq_two_iff
|
Mathlib.GroupTheory.Index
|
β {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
H.relIndex K = 2 β β a β K, β b β K, Xor' (b + a β H) (b β H)
|
ZMod.valMinAbs_natCast_eq_self._simp_1
|
Mathlib.Data.ZMod.ValMinAbs
|
β {n a : β} [NeZero n], ((βa).valMinAbs = βa) = (a β€ n / 2)
|
AddOpposite.instNonUnitalNonAssocSemiring._proof_2
|
Mathlib.Algebra.Ring.Opposite
|
β {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a b c : Rα΅α΅α΅), (a + b) * c = a * c + b * c
|
ModuleCon.instAddCommMagmaQuotient
|
Mathlib.Algebra.Module.Congruence.Defs
|
{S : Type u_2} β
(M : Type u_3) β
[inst : SMul S M] β [inst_1 : AddCommMagma M] β (c : ModuleCon S M) β AddCommMagma (ModuleCon.Quotient M c)
|
List.diff.match_1
|
Batteries.Data.List.Basic
|
{Ξ± : Type u_1} β
(motive : List Ξ± β List Ξ± β Sort u_2) β
(x x_1 : List Ξ±) β
((l : List Ξ±) β motive l []) β ((lβ : List Ξ±) β (a : Ξ±) β (lβ : List Ξ±) β motive lβ (a :: lβ)) β motive x x_1
|
TypeVec.subtypeVal_diagSub
|
Mathlib.Data.TypeVec
|
β {n : β} {Ξ± : TypeVec.{u} n}, TypeVec.comp (TypeVec.subtypeVal Ξ±.repeatEq) TypeVec.diagSub = TypeVec.prod.diag
|
UniformSpace.replaceTopology_eq
|
Mathlib.Topology.UniformSpace.Defs
|
β {Ξ± : Type u_2} [i : TopologicalSpace Ξ±] (u : UniformSpace Ξ±) (h : i = u.toTopologicalSpace), u.replaceTopology h = u
|
Equiv.Perm.cycleOf_apply_apply_self
|
Mathlib.GroupTheory.Perm.Cycle.Factors
|
β {Ξ± : Type u_2} (f : Equiv.Perm Ξ±) [inst : DecidableRel f.SameCycle] (x : Ξ±), (f.cycleOf x) (f x) = f (f x)
|
instContinuousMulULift
|
Mathlib.Topology.Algebra.Monoid
|
β {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Mul M] [ContinuousMul M], ContinuousMul (ULift.{u, u_3} M)
|
Std.Iterators.Iter.forIn'_eq
|
Init.Data.Iterators.Lemmas.Consumers.Loop
|
β {Ξ± Ξ² : Type w} [inst : Std.Iterators.Iterator Ξ± Id Ξ²] [Std.Iterators.Finite Ξ± Id] {m : Type x β Type x'}
[inst_2 : Monad m] [LawfulMonad m] [inst_4 : Std.Iterators.IteratorLoop Ξ± Id m]
[hl : Std.Iterators.LawfulIteratorLoop Ξ± Id m] {Ξ³ : Type x} {it : Std.Iter Ξ²} {init : Ξ³}
{f : (b : Ξ²) β it.IsPlausibleIndirectOutput b β Ξ³ β m (ForInStep Ξ³)},
forIn' it init f =
Std.Iterators.IterM.DefaultConsumers.forIn' (fun x x_1 f x_2 => f x_2.run) Ξ³ (fun x x_1 x_2 => True) it.toIterM init
it.toIterM.IsPlausibleIndirectOutput β― fun out h acc => do
let __do_lift β f out β― acc
pure β¨__do_lift, trivialβ©
|
WithZero.mapAddHom_injective
|
Mathlib.Algebra.Group.WithOne.Basic
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : Add Ξ±] [inst_1 : Add Ξ²] {f : Ξ± ββ+ Ξ²},
Function.Injective βf β Function.Injective β(WithZero.mapAddHom f)
|
_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_sum_fib._simp_1_15
|
Mathlib.Data.Nat.Fib.Zeckendorf
|
β {Ξ± : Type u} [inst : AddZeroClass Ξ±] [inst_1 : LE Ξ±] [CanonicallyOrderedAdd Ξ±] (a : Ξ±), (0 β€ a) = True
|
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionActionOfMonoidalFunctorToEndofunctorMopIso
|
Mathlib.CategoryTheory.Monoidal.Action.End
|
{C : Type u_1} β
{D : Type u_2} β
[inst : CategoryTheory.Category.{v_1, u_1} C] β
[inst_1 : CategoryTheory.MonoidalCategory C] β
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] β
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)α΄Ήα΅α΅) β
[inst_3 : F.Monoidal] β CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedActionMop C D β
F
|
NormedRing.inverse_add_norm
|
Mathlib.Analysis.Normed.Ring.Units
|
β {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R] (x : RΛ£),
(fun t => Ring.inverse (βx + t)) =O[nhds 0] fun _t => 1
|
nonempty_subtype
|
Mathlib.Logic.Nonempty
|
β {Ξ± : Sort u_3} {p : Ξ± β Prop}, Nonempty (Subtype p) β β a, p a
|
CategoryTheory.Over.pullback.congr_simp
|
Mathlib.CategoryTheory.Comma.Over.Pullback
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f f_1 : X βΆ Y) (e_f : f = f_1)
[inst_1 : CategoryTheory.Limits.HasPullbacksAlong f],
CategoryTheory.Over.pullback f = CategoryTheory.Over.pullback f_1
|
SSet.stdSimplex.instFunLikeObjOppositeSimplexCategoryMkOpFinHAddNatOfNat
|
Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex
|
(n i : β) β
FunLike ((SSet.stdSimplex.obj (SimplexCategory.mk n)).obj (Opposite.op (SimplexCategory.mk i))) (Fin (i + 1))
(Fin (n + 1))
|
NumberField.nrRealPlaces_eq_zero_iff
|
Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex
|
β {K : Type u_2} [inst : Field K] [inst_1 : NumberField K],
NumberField.InfinitePlace.nrRealPlaces K = 0 β NumberField.IsTotallyComplex K
|
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go.eq_2
|
Init.Data.List.Sort.Impl
|
β {Ξ± : Type u_1} (le : Ξ± β Ξ± β Bool) (x x_1 : List Ξ±),
(x = [] β False) β List.MergeSort.Internal.mergeTR.goβ le x [] x_1 = x_1.reverseAux x
|
HasCompactMulSupport.comp_homeomorph
|
Mathlib.Topology.Algebra.Support
|
β {X : Type u_9} {Y : Type u_10} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {M : Type u_11}
[inst_2 : One M] {f : Y β M}, HasCompactMulSupport f β β (Ο : X ββ Y), HasCompactMulSupport (f β βΟ)
|
CategoryTheory.Limits.MultispanShape._sizeOf_1
|
Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
|
CategoryTheory.Limits.MultispanShape β β
|
differentiableOn_intCast
|
Mathlib.Analysis.Calculus.FDeriv.Const
|
β {π : Type u_1} [inst : NontriviallyNormedField π] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace π E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace π F] {s : Set E}
[inst_5 : IntCast F] (z : β€), DifferentiableOn π (βz) s
|
Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElim
|
Std.Tactic.BVDecide.LRAT.Internal.Assignment
|
{motive : Std.Tactic.BVDecide.LRAT.Internal.Assignment β Sort u} β
(ctorIdx : β) β
(t : Std.Tactic.BVDecide.LRAT.Internal.Assignment) β
ctorIdx = t.ctorIdx β Std.Tactic.BVDecide.LRAT.Internal.Assignment.ctorElimType ctorIdx β motive t
|
String.valid_toSubstring
|
Batteries.Data.String.Lemmas
|
β (s : String), s.toRawSubstring.Valid
|
OrderIso.setIsotypicComponents_apply
|
Mathlib.RingTheory.SimpleModule.Isotypic
|
β {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M] (s : Set β(isotypicComponents R M)),
OrderIso.setIsotypicComponents s = β¨ c β s, β¨βc, β―β©
|
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.addAuxRecs.match_1
|
Lean.Elab.MutualInductive
|
(motive : Option Lean.ConstantInfo β Sort u_1) β
(x : Option Lean.ConstantInfo) β
((const : Lean.ConstantInfo) β motive (some const)) β ((x : Option Lean.ConstantInfo) β motive x) β motive x
|
PSigma.Lex.recOn
|
Init.WF
|
β {Ξ± : Sort u} {Ξ² : Ξ± β Sort v} {r : Ξ± β Ξ± β Prop} {s : (a : Ξ±) β Ξ² a β Ξ² a β Prop}
{motive : (a a_1 : PSigma Ξ²) β PSigma.Lex r s a a_1 β Prop} {a a_1 : PSigma Ξ²} (t : PSigma.Lex r s a a_1),
(β {aβ : Ξ±} (bβ : Ξ² aβ) {aβ : Ξ±} (bβ : Ξ² aβ) (a : r aβ aβ), motive β¨aβ, bββ© β¨aβ, bββ© β―) β
(β (a : Ξ±) {bβ bβ : Ξ² a} (a_2 : s a bβ bβ), motive β¨a, bββ© β¨a, bββ© β―) β motive a a_1 t
|
finsum_eq_if
|
Mathlib.Algebra.BigOperators.Finprod
|
β {M : Type u_2} [inst : AddCommMonoid M] {p : Prop} [inst_1 : Decidable p] {x : M}, βαΆ (_ : p), x = if p then x else 0
|
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqPoly.beq.match_1.splitter
|
Init.Grind.Ring.CommSolver
|
(motive : Lean.Grind.CommRing.Poly β Lean.Grind.CommRing.Poly β Sort u_1) β
(x x_1 : Lean.Grind.CommRing.Poly) β
((a b : β€) β motive (Lean.Grind.CommRing.Poly.num a) (Lean.Grind.CommRing.Poly.num b)) β
((a : β€) β
(a_1 : Lean.Grind.CommRing.Mon) β
(a_2 : Lean.Grind.CommRing.Poly) β
(b : β€) β
(b_1 : Lean.Grind.CommRing.Mon) β
(b_2 : Lean.Grind.CommRing.Poly) β
motive (Lean.Grind.CommRing.Poly.add a a_1 a_2) (Lean.Grind.CommRing.Poly.add b b_1 b_2)) β
((x x_2 : Lean.Grind.CommRing.Poly) β
(β (a b : β€), x = Lean.Grind.CommRing.Poly.num a β x_2 = Lean.Grind.CommRing.Poly.num b β False) β
(β (a : β€) (a_1 : Lean.Grind.CommRing.Mon) (a_2 : Lean.Grind.CommRing.Poly) (b : β€)
(b_1 : Lean.Grind.CommRing.Mon) (b_2 : Lean.Grind.CommRing.Poly),
x = Lean.Grind.CommRing.Poly.add a a_1 a_2 β x_2 = Lean.Grind.CommRing.Poly.add b b_1 b_2 β False) β
motive x x_2) β
motive x x_1
|
Nat.recDiagAux_succ_succ
|
Batteries.Data.Nat.Lemmas
|
β {motive : β β β β Sort u_1} (zero_left : (n : β) β motive 0 n) (zero_right : (m : β) β motive m 0)
(succ_succ : (m n : β) β motive m n β motive (m + 1) (n + 1)) (m n : β),
Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n)
|
CategoryTheory.Equivalence.changeFunctor._proof_2
|
Mathlib.CategoryTheory.Equivalence
|
β {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (e : C β D) {G : CategoryTheory.Functor C D} (iso : e.functor β
G)
(X : C),
CategoryTheory.CategoryStruct.comp
(G.map (CategoryTheory.CategoryStruct.comp (e.unitIso.hom.app X) (e.inverse.map (iso.hom.app X))))
(CategoryTheory.CategoryStruct.comp (iso.inv.app (e.inverse.obj (G.obj X))) (e.counitIso.hom.app (G.obj X))) =
CategoryTheory.CategoryStruct.id (G.obj X)
|
CategoryTheory.PreZeroHypercover.hom_inv_hβ._proof_1
|
Mathlib.CategoryTheory.Sites.Hypercover.Zero
|
β {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(e : E β
F) (i : E.Iβ), E.X i = E.X (e.inv.sβ (e.hom.sβ i))
|
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_11
|
Mathlib.RingTheory.LittleWedderburn
|
β {D : Type u_1} [inst : DivisionRing D] {R : Subring D} [inst_1 : Fintype D] [inst_2 : DecidableEq D]
[inst_3 : DecidablePred fun x => x β R] (q : ββ₯0) (a : β₯R), DivisionRing.nnqsmul q a = βq * a
|
_private.Mathlib.CategoryTheory.Limits.Opposites.0.CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ΞΉ._simp_1_1
|
Mathlib.CategoryTheory.Limits.Opposites
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (Ξ± : X β
Y) {f : X βΆ Z} {g : Y βΆ Z},
(CategoryTheory.CategoryStruct.comp Ξ±.hom g = f) = (g = CategoryTheory.CategoryStruct.comp Ξ±.inv f)
|
Lean.Elab.Command.Structure.checkValidFieldModifier
|
Lean.Elab.Structure
|
Lean.Elab.Modifiers β Lean.Elab.TermElabM Unit
|
LipschitzWith.compLp
|
Mathlib.MeasureTheory.Function.LpSpace.Basic
|
{Ξ± : Type u_1} β
{E : Type u_4} β
{F : Type u_5} β
{m : MeasurableSpace Ξ±} β
{p : ENNReal} β
{ΞΌ : MeasureTheory.Measure Ξ±} β
[inst : NormedAddCommGroup E] β
[inst_1 : NormedAddCommGroup F] β
{g : E β F} β
{c : NNReal} β LipschitzWith c g β g 0 = 0 β β₯(MeasureTheory.Lp E p ΞΌ) β β₯(MeasureTheory.Lp F p ΞΌ)
|
FormalMultilinearSeries.leftInv._proof_30
|
Mathlib.Analysis.Analytic.Inverse
|
β {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F
|
_private.Init.Data.Array.Lemmas.0.Array.range.eq_1
|
Init.Data.Array.Lemmas
|
β (n : β), Array.range n = Array.ofFn fun i => βi
|
List.merge_of_le
|
Init.Data.List.Sort.Lemmas
|
β {Ξ± : Type u_1} {le : Ξ± β Ξ± β Bool} {xs ys : List Ξ±},
(β (a b : Ξ±), a β xs β b β ys β le a b = true) β xs.merge ys le = xs ++ ys
|
Std.TreeMap.Raw.Equiv.getEntryLT?_eq
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp] {k : Ξ±},
tβ.WF β tβ.WF β tβ.Equiv tβ β tβ.getEntryLT? k = tβ.getEntryLT? k
|
CategoryTheory.StrictlyUnitaryLaxFunctorCore.mapβ_comp
|
Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary
|
β {B : Type uβ} [inst : CategoryTheory.Bicategory B] {C : Type uβ} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) {a b : B} {f g h : a βΆ b} (Ξ· : f βΆ g) (ΞΈ : g βΆ h),
self.mapβ (CategoryTheory.CategoryStruct.comp Ξ· ΞΈ) = CategoryTheory.CategoryStruct.comp (self.mapβ Ξ·) (self.mapβ ΞΈ)
|
Lean.Parser.Tactic.quot
|
Lean.Parser.Term
|
Lean.Parser.Parser
|
ContinuousMultilinearMap.currySumEquiv._proof_10
|
Mathlib.Analysis.Normed.Module.Multilinear.Curry
|
β (π : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField π] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace π G'], ContinuousConstSMul π G'
|
Std.TreeSet.Raw.toList_roc
|
Std.Data.TreeSet.Raw.Slice
|
β {Ξ± : Type u} (cmp : autoParam (Ξ± β Ξ± β Ordering) Std.TreeSet.Raw.toList_roc._auto_1) [Std.TransCmp cmp]
{t : Std.TreeSet.Raw Ξ± cmp},
t.WF β
β {lowerBound upperBound : Ξ±},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice t lowerBound<...=upperBound) =
List.filter (fun e => decide ((cmp e lowerBound).isGT = true β§ (cmp e upperBound).isLE = true)) t.toList
|
contMDiffOn_zero_iff
|
Mathlib.Geometry.Manifold.ContMDiff.Defs
|
β {π : 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'} {s : Set M},
ContMDiffOn I I' 0 f s β ContinuousOn f s
|
Fintype
|
Mathlib.Data.Fintype.Defs
|
Type u_4 β Type u_4
|
Subalgebra.val._proof_5
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
β {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (x : R), β((algebraMap R β₯S) x) = β((algebraMap R β₯S) x)
|
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.isType2Type._sparseCasesOn_2
|
Lean.PrettyPrinter.Delaborator.TopDownAnalyze
|
{motive : Lean.Expr β Sort u} β
(t : Lean.Expr) β ((u : Lean.Level) β motive (Lean.Expr.sort u)) β (Nat.hasNotBit 8 t.ctorIdx β motive t) β motive t
|
Rat.instNormedField
|
Mathlib.Analysis.Normed.Field.Lemmas
|
NormedField β
|
sqrt_one_add_norm_sq_le
|
Mathlib.Analysis.SpecialFunctions.JapaneseBracket
|
β {E : Type u_1} [inst : NormedAddCommGroup E] (x : E), β(1 + βxβ ^ 2) β€ 1 + βxβ
|
instAddUInt32
|
Init.Data.UInt.Basic
|
Add UInt32
|
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.instHasAffinePropertyQuasiCompactCompactSpaceCarrierCarrierCommRingCat._simp_2
|
Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact
|
β {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s = CompactSpace βs
|
div_right_injective
|
Mathlib.Algebra.Group.Basic
|
β {G : Type u_3} [inst : Group G] {b : G}, Function.Injective fun a => b / a
|
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow._proof_1_3
|
Init.Data.Nat.Bitwise.Lemmas
|
β {n m : β}, m < n β Β¬m β€ n β False
|
Prod.mk_le_mk._simp_1
|
Mathlib.Order.Basic
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} [inst : LE Ξ±] [inst_1 : LE Ξ²] {aβ aβ : Ξ±} {bβ bβ : Ξ²},
((aβ, bβ) β€ (aβ, bβ)) = (aβ β€ aβ β§ bβ β€ bβ)
|
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.exists_mem_stabilizer_smul_eq._proof_1_3
|
Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] {t : Set Ξ±},
β a β t, β b β t, β c β t, β β¦b_1 : Ξ±β¦, b_1 β t β (β(Equiv.swap c a) β β(Equiv.swap a b)) b_1 β t
|
_private.Init.Data.UInt.Lemmas.0.UInt32.ofNat_mul._simp_1_1
|
Init.Data.UInt.Lemmas
|
β (a : β) (b : UInt32), (UInt32.ofNat a = b) = (a % 2 ^ 32 = b.toNat)
|
Lean.FileMap.lineStart
|
Lean.Data.Position
|
Lean.FileMap β β β String.Pos.Raw
|
SimpleGraph.isNIndepSet_iff
|
Mathlib.Combinatorics.SimpleGraph.Clique
|
β {Ξ± : Type u_1} (G : SimpleGraph Ξ±) (n : β) (s : Finset Ξ±), G.IsNIndepSet n s β G.IsIndepSet βs β§ s.card = n
|
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Icc._simp_1_1
|
Mathlib.Order.Interval.Finset.Fin
|
β {Ξ± : Type u_1} {sβ sβ : Finset Ξ±}, (sβ = sβ) = (βsβ = βsβ)
|
CategoryTheory.Functor.LaxMonoidal.ΞΌ_whiskerRight_comp_ΞΌ_assoc
|
Mathlib.CategoryTheory.Monoidal.Functor
|
β {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.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.LaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z) βΆ
Z_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.LaxMonoidal.ΞΌ F X Y) (F.obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z) h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.LaxMonoidal.ΞΌ F Y Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.ΞΌ F X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv) h)))
|
Nat.gcd_sub_right_right_of_dvd
|
Init.Data.Nat.Gcd
|
β {m k : β} (n : β), k β€ m β n β£ k β n.gcd (m - k) = n.gcd m
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.