name
string | module
string | type
string |
|---|---|---|
Lean.Elab.Command.elabEvalCoreUnsafe
|
Lean.Elab.BuiltinEvalCommand
|
Bool → Lean.Syntax → Lean.Syntax → Option Lean.Expr → Lean.Elab.Command.CommandElabM Unit
|
CoxeterSystem.length_eq_one_iff
|
Mathlib.GroupTheory.Coxeter.Length
|
∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W},
cs.length w = 1 ↔ ∃ i, w = cs.simple i
|
Multiplicative.mulAction_isPretransitive
|
Mathlib.Algebra.Group.Action.Pretransitive
|
∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid α] [inst_1 : AddAction α β] [AddAction.IsPretransitive α β],
MulAction.IsPretransitive (Multiplicative α) β
|
MeasureTheory.integral_prod_swap
|
Mathlib.MeasureTheory.Integral.Prod
|
∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[inst_4 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] (f : α × β → E),
∫ (z : β × α), f z.swap ∂ν.prod μ = ∫ (z : α × β), f z ∂μ.prod ν
|
Mathlib.Tactic.Linarith.Comp.scale
|
Mathlib.Tactic.Linarith.Datatypes
|
Mathlib.Tactic.Linarith.Comp → ℕ → Mathlib.Tactic.Linarith.Comp
|
mul_le_of_mul_le_left
|
Mathlib.Algebra.Order.Monoid.Unbundled.Basic
|
∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulLeftMono α] {a b c d : α}, a * b ≤ c → d ≤ b → a * d ≤ c
|
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_fold_fn_preserves_induction_motive._simp_1_4
|
Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound
|
∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b)
|
div_div_eq_mul_div
|
Mathlib.Algebra.Group.Basic
|
∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b / c) = a * c / b
|
CommGroupWithZero.toCancelCommMonoidWithZero
|
Mathlib.Algebra.GroupWithZero.Units.Basic
|
{G₀ : Type u_3} → [CommGroupWithZero G₀] → CancelCommMonoidWithZero G₀
|
HomogeneousSubsemiring.ext
|
Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring
|
∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : AddMonoid ι] [inst_1 : Semiring A] [inst_2 : SetLike σ A]
[inst_3 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_4 : DecidableEq ι] [inst_5 : GradedRing 𝒜]
{R S : HomogeneousSubsemiring 𝒜}, R.toSubsemiring = S.toSubsemiring → R = S
|
CategoryTheory.Limits.IsLimit.pushoutOfHasExactLimitsOfShape._proof_2
|
Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected
|
∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.HasLimitsOfShape J C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cone F}
{X : C} (f : c.pt ⟶ X),
CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.pushout c.π ((CategoryTheory.Functor.const J).map f))
|
perfectClosure.eq_bot_of_isSeparable
|
Mathlib.FieldTheory.PurelyInseparable.PerfectClosure
|
∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
perfectClosure F E = ⊥
|
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartite.exists_isBipartiteWith._proof_1_3
|
Mathlib.Combinatorics.SimpleGraph.Bipartite
|
NeZero (1 + 1)
|
Std.Internal.List.getEntry?._sunfold
|
Std.Data.Internal.List.Associative
|
{α : Type u} → {β : α → Type v} → [BEq α] → α → List ((a : α) × β a) → Option ((a : α) × β a)
|
Lean.Parser.Term.leading_parser._regBuiltin.Lean.Parser.Term.withAnonymousAntiquot.parenthesizer_19
|
Lean.Parser.Term
|
IO Unit
|
Int.fib_neg_one
|
Mathlib.Data.Int.Fib.Basic
|
Int.fib (-1) = 1
|
MonadReader.casesOn
|
Init.Prelude
|
{ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadReader ρ m → Sort u_1} → (t : MonadReader ρ m) → ((read : m ρ) → motive { read := read }) → motive t
|
NumberField.instIsAlgebraicSubtypeMemSubfield
|
Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex
|
∀ {K : Type u_2} [inst : Field K] [inst_1 : CharZero K] [Algebra.IsAlgebraic ℚ K] (k : Subfield K),
Algebra.IsAlgebraic (↥k) K
|
Set.graphOn_singleton
|
Mathlib.Data.Set.Prod
|
∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : α), Set.graphOn f {x} = {(x, f x)}
|
CategoryTheory.Iso.isoCongr._proof_1
|
Mathlib.CategoryTheory.HomCongr
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X₁ Y₁ X₂ Y₂ : C} (f : X₁ ≅ X₂) (g : Y₁ ≅ Y₂),
Function.LeftInverse (fun h => f ≪≫ h ≪≫ g.symm) fun h => f.symm ≪≫ h ≪≫ g
|
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.norm_intCast_eq_one_iff._simp_1_3
|
Mathlib.NumberTheory.Padics.PadicNumbers
|
∀ {m n : ℤ}, IsCoprime m n = (m.gcd n = 1)
|
mul_le_mul_left_of_neg._simp_1
|
Mathlib.Algebra.Order.Ring.Unbundled.Basic
|
∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [AddRightMono R]
[AddRightReflectLE R] {a b c : R}, c < 0 → (c * a ≤ c * b) = (b ≤ a)
|
linearIndependent_fin_succ
|
Mathlib.LinearAlgebra.LinearIndependent.Lemmas
|
∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {n : ℕ}
{v : Fin (n + 1) → V},
LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (Set.range (Fin.tail v))
|
subset_affineSpan
|
Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs
|
∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P), s ⊆ ↑(affineSpan k s)
|
Lean.ScopedEnvExtension.State.mk.injEq
|
Lean.ScopedEnvExtension
|
∀ {σ : Type} (state : σ) (activeScopes : Lean.NameSet) (delimitsLocal : Bool) (state_1 : σ)
(activeScopes_1 : Lean.NameSet) (delimitsLocal_1 : Bool),
({ state := state, activeScopes := activeScopes, delimitsLocal := delimitsLocal } =
{ state := state_1, activeScopes := activeScopes_1, delimitsLocal := delimitsLocal_1 }) =
(state = state_1 ∧ activeScopes = activeScopes_1 ∧ delimitsLocal = delimitsLocal_1)
|
_private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasCoproduct_fin
|
Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C]
[CategoryTheory.Limits.HasInitial C] (n : ℕ) (f : Fin n → C), CategoryTheory.Limits.HasCoproduct f
|
Lean.Parser.Command.structExplicitBinder
|
Lean.Parser.Command
|
Lean.Parser.Parser
|
Lean.Meta.Contradiction.Config.emptyType
|
Lean.Meta.Tactic.Contradiction
|
Lean.Meta.Contradiction.Config → Bool
|
CoxeterSystem.length_wordProd_le
|
Mathlib.GroupTheory.Coxeter.Length
|
∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B),
cs.length (cs.wordProd ω) ≤ ω.length
|
MoritaEquivalence.mk.injEq
|
Mathlib.RingTheory.Morita.Basic
|
∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B] (eqv : ModuleCat A ≌ ModuleCat B)
(linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam)
(eqv_1 : ModuleCat A ≌ ModuleCat B)
(linear_1 : autoParam (CategoryTheory.Functor.Linear R eqv_1.functor) MoritaEquivalence.linear._autoParam),
({ eqv := eqv, linear := linear } = { eqv := eqv_1, linear := linear_1 }) = (eqv = eqv_1)
|
_auto._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.3813590702._hygCtx._hyg.61
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital
|
Lean.Syntax
|
Equiv.Perm.sign_inv
|
Mathlib.GroupTheory.Perm.Sign
|
∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] (f : Equiv.Perm α), Equiv.Perm.sign f⁻¹ = Equiv.Perm.sign f
|
RootableBy.mk._flat_ctor
|
Mathlib.GroupTheory.Divisible
|
{A : Type u_1} →
{α : Type u_2} →
[inst : Monoid A] →
[inst_1 : Pow A α] →
[inst_2 : Zero α] →
(root : A → α → A) →
(∀ (a : A), root a 0 = 1) → (∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a) → RootableBy A α
|
HahnEmbedding.Seed.hahnCoeff_apply
|
Mathlib.Algebra.Order.Module.HahnEmbedding
|
∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[inst_10 : LinearOrder R] [inst_11 : Module K R] (seed : HahnEmbedding.Seed K M R) {x : ↥seed.baseDomain}
{f : Π₀ (c : ArchimedeanClass M), ↥(seed.stratum c)},
(↑x = f.sum fun c => ⇑(seed.stratum c).subtype) →
∀ (c : ArchimedeanClass M), (seed.hahnCoeff x) c = (seed.coeff c) (f c)
|
Std.TreeMap.getKeyLT
|
Std.Data.TreeMap.AdditionalOperations
|
{α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.lt) → α
|
CategoryTheory.Subpresheaf.toRange.eq_1
|
Mathlib.CategoryTheory.Subpresheaf.Image
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor Cᵒᵖ (Type w)} (p : F' ⟶ F),
CategoryTheory.Subpresheaf.toRange p = CategoryTheory.Subpresheaf.lift p ⋯
|
TensorProduct.induction_on
|
Mathlib.LinearAlgebra.TensorProduct.Basic
|
∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {motive : TensorProduct R M N → Prop}
(z : TensorProduct R M N),
motive 0 →
(∀ (x : M) (y : N), motive (x ⊗ₜ[R] y)) →
(∀ (x y : TensorProduct R M N), motive x → motive y → motive (x + y)) → motive z
|
Finset.isPWO_support_addAntidiagonal
|
Mathlib.Data.Finset.MulAntidiagonal
|
∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO}, {a | (Finset.addAntidiagonal hs ht a).Nonempty}.IsPWO
|
CategoryTheory.Join.structuredArrowEquiv._proof_9
|
Mathlib.CategoryTheory.Join.Final
|
∀ (C : Type u_4) (D : Type u_3) [inst : CategoryTheory.Category.{u_2, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (c : C)
{X Y : CategoryTheory.StructuredArrow (CategoryTheory.Join.left c) (CategoryTheory.Join.inclRight C D)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl Y.right) ⋯).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.isoMk (CategoryTheory.Iso.refl X.right) ⋯).hom
(CategoryTheory.StructuredArrow.homMk f.right ⋯)
|
AddUnits.mulRight._simp_1
|
Mathlib.Algebra.Ring.Invertible
|
∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c
|
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.ne_bot_iff._simp_1_1
|
Mathlib.Data.Analysis.Filter
|
∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅)
|
CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsLimits_of_createsFiniteLimits
|
Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite
|
∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasFiniteLimits D]
[CategoryTheory.Limits.CreatesFiniteLimits F], CategoryTheory.Limits.HasFiniteLimits C
|
_private.Init.Data.SInt.Lemmas.0.Int32.toInt64_lt._simp_1_2
|
Init.Data.SInt.Lemmas
|
∀ {x y : Int64}, (x < y) = (x.toInt < y.toInt)
|
SSet.finite_of_hasDimensionLT
|
Mathlib.AlgebraicTopology.SimplicialSet.Finite
|
∀ (X : SSet) (d : ℕ) [X.HasDimensionLT d], (∀ i < d, Finite ↑(X.nonDegenerate i)) → X.Finite
|
Language.one_add_self_mul_kstar_eq_kstar
|
Mathlib.Computability.Language
|
∀ {α : Type u_1} (l : Language α), 1 + l * KStar.kstar l = KStar.kstar l
|
Int16.add_eq_left._simp_1
|
Init.Data.SInt.Lemmas
|
∀ {a b : Int16}, (a + b = a) = (b = 0)
|
Std.ExtDHashMap.getKey_eq_getKey!
|
Std.Data.ExtDHashMap.Lemmas
|
∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {a : α} {h : a ∈ m}, m.getKey a h = m.getKey! a
|
_private.Lean.Meta.LitValues.0.Lean.Meta.getListLitOf?.match_3
|
Lean.Meta.LitValues
|
{α : Type} →
(motive : Option (Option (Array α)) → Sort u_1) →
(x : Option (Option (Array α))) → (Unit → motive none) → ((a : Option (Array α)) → motive (some a)) → motive x
|
_private.Mathlib.Order.Filter.Map.0.Filter.compl_mem_kernMap._simp_1_1
|
Mathlib.Order.Filter.Map
|
∀ {α : Type u_1} {β : Type u_2} {m : α → β} {f : Filter α} {s : Set β},
(s ∈ Filter.kernMap m f) = ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
|
divp_mul_eq_mul_divp
|
Mathlib.Algebra.Group.Units.Basic
|
∀ {α : Type u} [inst : CommMonoid α] (x y : α) (u : αˣ), x /ₚ u * y = x * y /ₚ u
|
Std.Do.SPred.Tactic.instIsPure
|
Std.Do.SPred.DerivedLaws
|
∀ {φ : Prop} {σ : Type u_1} {s : σ} (σs : List (Type u_1)) (P : Std.Do.SPred (σ :: σs))
[inst : Std.Do.SPred.Tactic.IsPure P φ], Std.Do.SPred.Tactic.IsPure (P s) φ
|
String.Slice.RevByteIterator.ctorIdx
|
Init.Data.String.Slice
|
String.Slice.RevByteIterator → ℕ
|
Std.DTreeMap.Internal.Impl.get_insertIfNew!
|
Std.Data.DTreeMap.Internal.Lemmas
|
∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ Std.DTreeMap.Internal.Impl.insertIfNew! k v t},
(Std.DTreeMap.Internal.Impl.insertIfNew! k v t).get a h₁ =
if h₂ : compare k a = Ordering.eq ∧ k ∉ t then cast ⋯ v else t.get a ⋯
|
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.delete_iff
|
Std.Tactic.BVDecide.LRAT.Internal.Clause
|
∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)
(l l' : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
l' ∈ (c.delete l).toList ↔ l' ≠ l ∧ l' ∈ c.toList
|
Trivialization.continuousLinearEquivAt._proof_4
|
Mathlib.Topology.VectorBundle.Basic
|
∀ (R : Type u_3) {B : Type u_4} {F : Type u_1} {E : B → Type u_2} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E)]
(e : Trivialization F Bundle.TotalSpace.proj) [inst_7 : Trivialization.IsLinear R e] (b : B) (hb : b ∈ e.baseSet)
(m : R) (x : E b),
(↑(Pretrivialization.linearEquivAt R e.toPretrivialization b hb)).toFun (m • x) =
(RingHom.id R) m • (↑(Pretrivialization.linearEquivAt R e.toPretrivialization b hb)).toFun x
|
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.liftAux
|
Mathlib.FieldTheory.IsAlgClosed.Basic
|
(K : Type u_1) →
[inst : Field K] →
(L : Type u_2) →
(M : Type u_3) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[inst_3 : Field M] → [inst_4 : Algebra K M] → [IsAlgClosed M] → [Algebra.IsAlgebraic K L] → L →ₐ[K] M
|
_private.Mathlib.GroupTheory.Subgroup.Centralizer.0.Subgroup.normalizerMonoidHom_ker._simp_1_6
|
Mathlib.GroupTheory.Subgroup.Centralizer
|
∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b)
|
BestFirstNode.ctorIdx
|
Mathlib.Deprecated.MLList.BestFirst
|
{α : Sort u_1} → {ω : Type u_2} → {prio : α → Thunk ω} → {ε : α → Type} → BestFirstNode prio ε → ℕ
|
_private.Lean.Meta.Basic.0.Lean.Meta.isSyntheticMVar.match_1
|
Lean.Meta.Basic
|
(motive : Lean.MetavarKind → Sort u_1) →
(__do_lift : Lean.MetavarKind) →
(Unit → motive Lean.MetavarKind.synthetic) →
(Unit → motive Lean.MetavarKind.syntheticOpaque) → ((x : Lean.MetavarKind) → motive x) → motive __do_lift
|
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuousMap_continuous_integral
|
Mathlib.MeasureTheory.Measure.ProbabilityMeasure
|
∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x)
|
Metric.frontier_thickening_disjoint
|
Mathlib.Topology.MetricSpace.Thickening
|
∀ {α : Type u} [inst : PseudoEMetricSpace α] (A : Set α),
Pairwise (Function.onFun Disjoint fun r => frontier (Metric.thickening r A))
|
Lean.Elab.Term.MatchExpr.ElseAlt.mk.sizeOf_spec
|
Lean.Elab.MatchExpr
|
∀ (rhs : Lean.Syntax), sizeOf { rhs := rhs } = 1 + sizeOf rhs
|
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatDescFactorial._proof_2
|
Mathlib.Tactic.NormNum.NatFactorial
|
∀ (x y z : Q(ℕ)), «$x» =Q «$z» + «$y»
|
denselyOrdered_multiplicative_iff
|
Mathlib.GroupTheory.ArchimedeanDensely
|
∀ {X : Type u_2} [inst : LT X], DenselyOrdered (Multiplicative X) ↔ DenselyOrdered X
|
Lean.Lsp.SemanticTokenType.method.sizeOf_spec
|
Lean.Data.Lsp.LanguageFeatures
|
sizeOf Lean.Lsp.SemanticTokenType.method = 1
|
GrpCat.uliftFunctor_preservesLimitsOfSize
|
Mathlib.Algebra.Category.Grp.Ulift
|
CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} GrpCat.uliftFunctor
|
MeasureTheory.regular_inv_iff
|
Mathlib.MeasureTheory.Group.Measure
|
∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G], μ.inv.Regular ↔ μ.Regular
|
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter.match_3.eq_3
|
Std.Data.DTreeMap.Internal.Operations
|
∀ (motive : Ordering → Sort u_1) (h_1 : Ordering.eq = Ordering.lt → motive Ordering.lt)
(h_2 : Ordering.eq = Ordering.gt → motive Ordering.gt) (h_3 : Ordering.eq = Ordering.eq → motive Ordering.eq),
(match h : Ordering.eq with
| Ordering.lt => h_1 h
| Ordering.gt => h_2 h
| Ordering.eq => h_3 h) =
h_3 ⋯
|
ULift.semiring._proof_5
|
Mathlib.Algebra.Ring.ULift
|
∀ {R : Type u_2} [inst : Semiring R] (x : ULift.{u_1, u_2} R), Monoid.npow 0 x = 1
|
Std.instForInOfStream
|
Init.Data.Stream
|
{ρ : Type u_1} → {α : Type u_2} → {m : Type u_3 → Type u_4} → [Std.Stream ρ α] → ForIn m ρ α
|
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.nonempty_algHom_adjoin_of_splits.match_1_1
|
Mathlib.FieldTheory.Extension
|
∀ {F : Type u_3} {E : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] {S : Set E}
(motive : (∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb) → Prop)
(x : ∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb),
(∀ (φ : ↥(IntermediateField.adjoin F S) →ₐ[F] K) (h : φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb), motive ⋯) →
motive x
|
CategoryTheory.Limits.CatCospanTransform.inv_whiskerRight
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform
|
∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
[inst_6 : CategoryTheory.Category.{v₇, u₇} A''] [inst_7 : CategoryTheory.Category.{v₈, u₈} B'']
[inst_8 : CategoryTheory.Category.{v₉, u₉} C''] {F'' : CategoryTheory.Functor A'' B''}
{G'' : CategoryTheory.Functor C'' B''} {ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'} (η : ψ ⟶ ψ')
[inst_9 : CategoryTheory.IsIso η] {φ : CategoryTheory.Limits.CatCospanTransform F' G' F'' G''},
CategoryTheory.inv (CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight η φ) =
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerRight (CategoryTheory.inv η) φ
|
EReal.abs_neg
|
Mathlib.Data.EReal.Inv
|
∀ (x : EReal), (-x).abs = x.abs
|
Mathlib.Tactic.Ring.ExProd.cast._unsafe_rec
|
Mathlib.Tactic.Ring.Basic
|
{u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
{a : Q(«$α»)} → Mathlib.Tactic.Ring.ExProd sα a → (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExProd sβ a
|
riemannianMetricVectorSpace._proof_7
|
Mathlib.Geometry.Manifold.Riemannian.Basic
|
ContinuousConstSMul ℝ ℝ
|
Matrix.mem_range_scalar_iff_commute_stdBasisMatrix
|
Mathlib.Data.Matrix.Basis
|
∀ {n : Type u_3} {α : Type u_7} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring α] {M : Matrix n n α},
M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), i ≠ j → Commute (Matrix.single i j 1) M
|
NumberField.mixedEmbedding.convexBodySum.congr_simp
|
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody
|
∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B B_1 : ℝ),
B = B_1 →
∀ (a a_1 : NumberField.mixedEmbedding.mixedSpace K),
a = a_1 → NumberField.mixedEmbedding.convexBodySum K B a = NumberField.mixedEmbedding.convexBodySum K B_1 a_1
|
AntivaryOn.neg_left
|
Mathlib.Algebra.Order.Monovary
|
∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn f g s → MonovaryOn (-f) g s
|
_private.Lean.Elab.Tactic.Change.0.Lean.Elab.Tactic.evalChange.match_1
|
Lean.Elab.Tactic.Change
|
(motive : Lean.Expr × List Lean.MVarId → Sort u_1) →
(__discr : Lean.Expr × List Lean.MVarId) →
((hTy' : Lean.Expr) → (mvars : List Lean.MVarId) → motive (hTy', mvars)) → motive __discr
|
Lean.Parser.Term.debugAssert._regBuiltin.Lean.Parser.Term.debugAssert.parenthesizer_11
|
Lean.Parser.Term
|
IO Unit
|
Ideal.IsHomogeneous.iSup₂
|
Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal
|
∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} {f : (i : κ) → κ' i → Ideal A},
(∀ (i : κ) (j : κ' i), Ideal.IsHomogeneous 𝒜 (f i j)) → Ideal.IsHomogeneous 𝒜 (⨆ i, ⨆ j, f i j)
|
List.max?.eq_1
|
Init.Data.List.MinMax
|
∀ {α : Type u} [inst : Max α], [].max? = none
|
Equiv.Perm.toList_ne_singleton
|
Mathlib.GroupTheory.Perm.Cycle.Concrete
|
∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : Equiv.Perm α) (x y : α), p.toList x ≠ [y]
|
CategoryTheory.Limits.IsZero.iso._proof_1
|
Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X),
CategoryTheory.CategoryStruct.comp (hX.to_ Y) (hX.from_ Y) = CategoryTheory.CategoryStruct.id X
|
LowerSet.instDiv._proof_1
|
Mathlib.Algebra.Order.UpperLower
|
∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (s t : LowerSet α),
IsLowerSet (s.carrier / ↑t)
|
_private.Mathlib.Algebra.Free.0.FreeMagma.length_pos.match_1_1
|
Mathlib.Algebra.Free
|
∀ {α : Type u_1} (motive : FreeMagma α → Prop) (x : FreeMagma α),
(∀ (a : α), motive (FreeMagma.of a)) → (∀ (y z : FreeMagma α), motive (y.mul z)) → motive x
|
Membership.mem.out
|
Mathlib.Data.Set.Operations
|
∀ {α : Type u} {a : α} {p : α → Prop}, a ∈ {x | p x} → p a
|
CategoryTheory.Limits.pullbackConeOfLeftIso_fst
|
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso
|
∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).fst = CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f)
|
QuotientAddGroup.lift._proof_2
|
Mathlib.GroupTheory.QuotientGroup.Defs
|
∀ {G : Type u_1} {M : Type u_2} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M), N ≤ φ.ker → QuotientAddGroup.con N ≤ AddCon.ker φ
|
SignType.ofNat
|
Mathlib.Data.Sign.Defs
|
ℕ → SignType
|
Filter.Germ.instSemigroup._proof_1
|
Mathlib.Order.Filter.Germ.Basic
|
∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : Semigroup M] (a b c : l.Germ M), a * b * c = a * (b * c)
|
Int.mul_tmod_left
|
Init.Data.Int.DivMod.Lemmas
|
∀ (a b : ℤ), (a * b).tmod b = 0
|
Lean.Lsp.ReferenceContext.rec
|
Lean.Data.Lsp.LanguageFeatures
|
{motive : Lean.Lsp.ReferenceContext → Sort u} →
((includeDeclaration : Bool) → motive { includeDeclaration := includeDeclaration }) →
(t : Lean.Lsp.ReferenceContext) → motive t
|
Mathlib.Meta.Positivity.evalFinsetSum
|
Mathlib.Tactic.Positivity.Finset
|
Mathlib.Meta.Positivity.PositivityExt
|
_private.Init.Grind.Offset.0.Lean.Grind.Nat.le_offset._proof_1_1
|
Init.Grind.Offset
|
∀ (a k : ℕ), ¬k ≤ a + k → False
|
CategoryTheory.CommGrp.forget₂Grp_obj_one
|
Mathlib.CategoryTheory.Monoidal.CommGrp_
|
∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
CategoryTheory.MonObj.one = CategoryTheory.MonObj.one
|
AffineBasis.tot
|
Mathlib.LinearAlgebra.AffineSpace.Basis
|
∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P), affineSpan k (Set.range ⇑b) = ⊤
|
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_1
|
Mathlib.Algebra.Order.Group.Pointwise.Interval
|
∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b
|
AddCommGrpCat.forget_commGrp_preserves_epi
|
Mathlib.Algebra.Category.Grp.EpiMono
|
(CategoryTheory.forget AddCommGrpCat).PreservesEpimorphisms
|
Set.Icc.instOne.congr_simp
|
Mathlib.Topology.Homotopy.Basic
|
∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R],
Set.Icc.instOne = Set.Icc.instOne
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.