name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Algebra.Lie.Killing.0.LieAlgebra.killingForm_of_equiv_apply._simp_1_1 | Mathlib.Algebra.Lie.Killing | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (e : L ≃ₗ⁅R⁆ L') (x : L),
(LieAlgebra.ad R L') (e x) = e.toLinearEquiv.conj ((LieAlgebra.ad R L) x) |
CategoryTheory.Limits.colimitConstInitial | Mathlib.CategoryTheory.Limits.Shapes.Terminal | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasInitial C] →
CategoryTheory.Limits.colimit ((CategoryTheory.Functor.const J).obj (⊥_ C)) ≅ ⊥_ C |
ContextFreeRule.reverse_injective | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {N : Type u_2}, Function.Injective ContextFreeRule.reverse |
Std.Iterators.Types.ULiftIterator.instIterator._proof_1 | Init.Data.Iterators.Combinators.Monadic.ULift | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {n : Type (max u_1 u_3) → Type u_4} {β : Type u_1}
{lift : ⦃γ : Type u_1⦄ → m γ → Std.Iterators.ULiftT n γ} [inst : Std.Iterator α m β]
(it : Std.IterM n (ULift.{u_3, u_1} β)) (__do_lift : ULift.{u_3, u_1} (Std.Shrink it.internalState.inner.Step)),
∃ step',
it.internalState.inner.IsPlausibleStep step' ∧
Std.Iterators.Types.ULiftIterator.Monadic.modifyStep ↑__do_lift.down.inflate =
Std.Iterators.Types.ULiftIterator.Monadic.modifyStep step' |
MvPolynomial.finSuccEquiv_apply | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) [inst : CommSemiring R] (n : ℕ) (p : MvPolynomial (Fin (n + 1)) R),
(MvPolynomial.finSuccEquiv R n) p =
(MvPolynomial.eval₂Hom (Polynomial.C.comp MvPolynomial.C) fun i =>
Fin.cases Polynomial.X (fun k => Polynomial.C (MvPolynomial.X k)) i)
p |
AddSubmonoid.zero_mem' | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_3} [inst : AddZeroClass M] (self : AddSubmonoid M), 0 ∈ self.carrier |
iInf_uniformity | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}, uniformity α = ⨅ i, uniformity α |
Std.LawfulOrderLeftLeaningMax.max_eq_left | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} {inst_1 : LE α} [self : Std.LawfulOrderLeftLeaningMax α] (a b : α), b ≤ a → a ⊔ b = a |
List.pairwise_cons_cons | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {R : α → α → Prop} {a b : α} {l : List α},
List.Pairwise R (a :: b :: l) ↔ R a b ∧ List.Pairwise R (a :: l) ∧ List.Pairwise R (b :: l) |
Fin.forall_fin_zero._simp_1 | Init.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True |
Aesop.TreeRef.markSubtreeIrrelevant | Aesop.Tree.State | Aesop.TreeRef → BaseIO Unit |
Lean.Elab.Command.instMonadLogCommandElabM | Lean.Elab.Command | Lean.MonadLog Lean.Elab.Command.CommandElabM |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.State.map | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.State✝ → Std.HashMap Lean.Meta.Sym.ExprPtr Lean.Expr |
List.isChain_of_isChain_map | Mathlib.Data.List.Chain | ∀ {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β),
(∀ (a b : α), S (f a) (f b) → R a b) → ∀ {l : List α}, List.IsChain S (List.map f l) → List.IsChain R l |
Matroid.isBase_restrict_iff._simp_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α},
autoParam (X ⊆ M.E) Matroid.isBase_restrict_iff._auto_1 → (M.restrict X).IsBase I = M.IsBasis I X |
Std.TreeMap.Raw.getElem_filterMap'._proof_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}
[inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {f : α → β → Option γ} {k : α} {g : k ∈ Std.TreeMap.Raw.filterMap f t}
(h : t.WF), (f k t[k]).isSome = true |
Lean.Elab.Tactic.GuardMsgs.GuardMsgFailure.mk.sizeOf_spec | Lean.Elab.GuardMsgs | ∀ (res : String), sizeOf { res := res } = 1 + sizeOf res |
Std.instAntisymmOfAsymm | Init.Data.Order.Lemmas | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Asymm r], Std.Antisymm r |
List.suffix_cons._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (a : α) (l : List α), (l <:+ a :: l) = True |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerLeft_naturality_naturality_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.Pseudofunctor B C} (θ : G ⟶ H) {a b : B} {a' : C} (f : a' ⟶ G.obj a) {g h : a ⟶ b} (β : g ⟶ h)
{Z : a' ⟶ H.obj b}
(h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (θ.app a) (H.map h)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight (G.map₂ β) (θ.app b)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft f (θ.naturality h).hom) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft f (θ.naturality g).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerLeft (θ.app a) (H.map₂ β))) h_1) |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.one_mem_div_iff._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, (a / b = 1) = (a = b) |
Std.Internal.UV.UDP.Socket.bind | Std.Internal.UV.UDP | Std.Internal.UV.UDP.Socket → Std.Net.SocketAddress → IO Unit |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.mk | Std.Time.Format.Basic | Option Std.Time.Year.Era →
Option Std.Time.Year.Offset →
Option Std.Time.Year.Offset →
Option (Sigma Std.Time.Day.Ordinal.OfYear) →
Option Std.Time.Month.Ordinal →
Option Std.Time.Day.Ordinal →
Option Std.Time.Month.Quarter →
Option Std.Time.Week.Ordinal →
Option Std.Time.Week.Ordinal.OfMonth →
Option Std.Time.Weekday →
Option Std.Time.Weekday →
Option (Std.Time.Internal.Bounded.LE 1 5) →
Option Std.Time.HourMarker →
Option (Std.Time.Internal.Bounded.LE 1 12) →
Option (Std.Time.Internal.Bounded.LE 0 11) →
Option (Std.Time.Internal.Bounded.LE 1 24) →
Option Std.Time.Hour.Ordinal →
Option Std.Time.Minute.Ordinal →
Option (Std.Time.Second.Ordinal true) →
Option Std.Time.Nanosecond.Ordinal →
Option Std.Time.Millisecond.Offset →
Option Std.Time.Nanosecond.Ordinal →
Option Std.Time.Nanosecond.Offset →
Option String →
Option String →
Option String →
Option Std.Time.TimeZone.Offset →
Option Std.Time.TimeZone.Offset →
Option Std.Time.TimeZone.Offset →
Option Std.Time.TimeZone.Offset →
Std.Time.GenericFormat.DateBuilder✝ |
Lean.getStructureCtor | Lean.Structure | Lean.Environment → Lean.Name → Lean.ConstructorVal |
AffineIsometryEquiv.linearIsometryEquiv._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) |
LinearMap.mulRight_inj._simp_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_6} {A : Type u_7} [inst : Semiring R] [inst_1 : NonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {a b : A}, (LinearMap.mulRight R a = LinearMap.mulRight R b) = (a = b) |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.seminormAux_le_bound | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F) {M : ℝ},
0 ≤ M → (∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ M) → SchwartzMap.seminormAux✝ k n f ≤ M |
Task.spawn | Init.Core | {α : Type u} → (Unit → α) → optParam Task.Priority Task.Priority.default → Task α |
ContinuousLinearMap.flipₗᵢ._proof_7 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ (Gₗ : Type u_1) [inst : SeminormedAddCommGroup Gₗ], ContinuousAdd Gₗ |
Int.sum_div | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_5} {s : Finset ι} {f : ι → ℤ} {n : ℤ}, (∀ i ∈ s, n ∣ f i) → (∑ i ∈ s, f i) / n = ∑ i ∈ s, f i / n |
OreLocalization.lift₂Expand_of | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_3}
[inst_2 : MulAction R X] {C : Sort u_2} {P : X → ↥S → X → ↥S → C}
{hP :
∀ (r₁ : X) (t₁ : R) (s₁ : ↥S) (ht₁ : t₁ * ↑s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : ↥S) (ht₂ : t₂ * ↑s₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨t₁ * ↑s₁, ht₁⟩ (t₂ • r₂) ⟨t₂ * ↑s₂, ht₂⟩}
(r₁ : X) (s₁ : ↥S) (r₂ : X) (s₂ : ↥S), OreLocalization.lift₂Expand P hP (r₁ /ₒ s₁) (r₂ /ₒ s₂) = P r₁ s₁ r₂ s₂ |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_4 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂}, (f.range = ⊤) = Function.Surjective ⇑f |
WithLp.pseudoMetricSpaceToProd._proof_1 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) [hp : Fact (1 ≤ p)] (α : Type u_1) (β : Type u_2) [inst : PseudoMetricSpace α]
[inst_1 : PseudoMetricSpace β], IsUniformInducing (WithLp.toLp p) |
nhdsWithin_restrict | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} (s : Set α) {t : Set α},
a ∈ t → IsOpen t → nhdsWithin a s = nhdsWithin a (s ∩ t) |
_private.Init.Data.List.Impl.0.List.takeTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → List α → List α → ℕ → Array α → List α |
Set.preimage_mul_const_Ico₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {c : G₀} (a b : G₀),
0 < c → (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c) |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_shift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ (a m p q : ℤ), p + m = q → p + a + m = q + a |
instCommSemiringWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_2} [inst : CommSemiring α] (a b : WithConv (Matrix m n α)), a * b = b * a |
AddCommGrpCat.kernelIsoKer._proof_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {G H : AddCommGrpCat} (f : G ⟶ H), ⟨(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.kernel.ι f)) 0, ⋯⟩ = 0 |
Finsupp.sigmaFinsuppLEquivPiFinsupp_apply | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ (R : Type u_5) [inst : Semiring R] {η : Type u_7} [inst_1 : Fintype η] {M : Type u_9} {ιs : η → Type u_10}
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (f : (j : η) × ιs j →₀ M) (j : η) (i : ιs j),
((Finsupp.sigmaFinsuppLEquivPiFinsupp R) f j) i = f ⟨j, i⟩ |
Lean.Compiler.LCNF.FixedParams.AbsValue.val | Lean.Compiler.LCNF.FixedParams | ℕ → Lean.Compiler.LCNF.FixedParams.AbsValue |
Class.mem_wf | Mathlib.SetTheory.ZFC.Class | WellFounded fun x1 x2 => x1 ∈ x2 |
_private.Mathlib.GroupTheory.Solvable.0.isSolvable_of_subsingleton._simp_1 | Mathlib.GroupTheory.Solvable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True |
finTwoEquiv._proof_6 | Mathlib.Logic.Equiv.Defs | NeZero (1 + 1) |
TypeVec.repeatEq.match_1 | Mathlib.Data.TypeVec | (motive : (x : ℕ) → TypeVec.{u_1} x → Sort u_2) →
(x : ℕ) →
(x_1 : TypeVec.{u_1} x) →
((x : TypeVec.{u_1} 0) → motive 0 x) → ((n : ℕ) → (α : TypeVec.{u_1} n.succ) → motive n.succ α) → motive x x_1 |
NonUnitalSubsemiring.mem_map._simp_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] {F : Type u_1}
[inst_2 : FunLike F R S] [inst_3 : NonUnitalRingHomClass F R S] {f : F} {s : NonUnitalSubsemiring R} {y : S},
(y ∈ NonUnitalSubsemiring.map f s) = ∃ x ∈ s, f x = y |
Lean.Meta.Grind.Arith.CommRing.ProofM.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | Lean.Meta.Grind.Arith.CommRing.ProofM.State → ℕ |
PartOrdEmb.Hom.noConfusionType | Mathlib.Order.Category.PartOrdEmb | Sort u_1 → {X Y : PartOrdEmb} → X.Hom Y → {X' Y' : PartOrdEmb} → X'.Hom Y' → Sort u_1 |
Prime.coprime_iff_not_dvd | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : CommRing R] [IsBezout R] [IsDomain R] {p n : R}, Prime p → (IsCoprime p n ↔ ¬p ∣ n) |
singleton_div_ball | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E), {x} / Metric.ball y δ = Metric.ball (x / y) δ |
ENNReal.rpow_add_rpow_le_add | Mathlib.Analysis.MeanInequalitiesPow | ∀ {p : ℝ} (a b : ENNReal), 1 ≤ p → (a ^ p + b ^ p) ^ (1 / p) ≤ a + b |
Equiv.prodCongr_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_9} {α₂ : Type u_10} {β₁ : Type u_11} {β₂ : Type u_12} (e₁ : α₁ ≃ α₂) (e₂ : β₁ ≃ β₂),
⇑(e₁.prodCongr e₂) = Prod.map ⇑e₁ ⇑e₂ |
Filter.Realizer.comap | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {β : Type u_2} → (m : α → β) → {f : Filter β} → f.Realizer → (Filter.comap m f).Realizer |
Ctop.Realizer.isClosed_iff | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (F : Ctop.Realizer α) {s : Set α},
IsClosed s ↔ ∀ (a : α), (∀ (b : F.σ), a ∈ F.F.f b → ∃ z, z ∈ F.F.f b ∩ s) → a ∈ s |
Std.Time.GenericFormat.mk.injEq | Std.Time.Format.Basic | ∀ {awareness : Std.Time.Awareness} (config : Std.Time.FormatConfig) (string : Std.Time.FormatString)
(config_1 : Std.Time.FormatConfig) (string_1 : Std.Time.FormatString),
({ config := config, string := string } = { config := config_1, string := string_1 }) =
(config = config_1 ∧ string = string_1) |
NonUnitalSubsemiring.mem_top | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (x : R), x ∈ ⊤ |
_private.Mathlib.Data.List.Defs.0.List.Forall.match_1.eq_2 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (motive : List α → Sort u_2) (x : α) (h_1 : Unit → motive []) (h_2 : (x : α) → motive [x])
(h_3 : (x : α) → (l : List α) → motive (x :: l)),
(match [x] with
| [] => h_1 ()
| [x] => h_2 x
| x :: l => h_3 x l) =
h_2 x |
ValueDistribution.logCounting_monotoneOn | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {f : 𝕜 → E} {e : WithTop E},
MonotoneOn (ValueDistribution.logCounting f e) (Set.Ioi 0) |
Multiset.count_sum' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} [inst : DecidableEq α] {s : Finset ι} {a : α} {f : ι → Multiset α},
Multiset.count a (∑ x ∈ s, f x) = ∑ x ∈ s, Multiset.count a (f x) |
Set.Ioo_subset_Iio_self | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b ⊆ Set.Iio b |
NonAssocCommSemiring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u} → (α → α → α) → α → α → ℕ → α |
Int64.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toISize = OfNat.ofNat n |
ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
Subgroup.comap A.unitGroup.subtype A.principalUnitGroup = A.unitGroupToResidueFieldUnits.ker |
Int32.one_mul | Init.Data.SInt.Lemmas | ∀ (a : Int32), 1 * a = a |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.rec | Lean.Compiler.LCNF.ExplicitRC | {motive : Lean.Compiler.LCNF.DerivedValInfo✝ → Sort u} →
((parent? : Option Lean.FVarId) →
(children : Lean.FVarIdHashSet) → motive { parent? := parent?, children := children }) →
(t : Lean.Compiler.LCNF.DerivedValInfo✝¹) → motive t |
Filter.Realizer.comap._proof_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {β : Type u_1} (m : α → β) {f : Filter β} (F : f.Realizer) (x x_1 : F.σ),
m ⁻¹' F.F.f (F.F.inf x x_1) ⊆ m ⁻¹' F.F.f x |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map._proof_6 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {j : J} (i₂ : J) (h₁ : i₂ ≤ j), ↑⟨i₂, h₁⟩ ≤ Order.succ j |
Batteries.BinomialHeap.Imp.Heap.foldM._unary | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} → [Monad m] → (α → α → Bool) → (β → α → m β) → (_ : Batteries.BinomialHeap.Imp.Heap α) ×' β → m β |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux._proof_1_4 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (j : ℕ) (i : Fin n), ↑i < j + 1 → ¬↑i = j → ¬↑i < j → False |
Subbimodule.toSubmodule._proof_1 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_3} {B : Type u_2} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsScalarTower R B M]
[inst_11 : SMulCommClass A B M] (p : Submodule (TensorProduct R A B) M) {a b : M},
a ∈ p.carrier → b ∈ p.carrier → a + b ∈ p.carrier |
_private.Mathlib.Order.LatticeIntervals.0.Set.Iic.disjoint_iff._simp_1_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) |
Pell.x_sub_y_dvd_pow | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (y n : ℕ), 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ Pell.yz a1 n * (↑a - ↑y) + ↑(y ^ n) - Pell.xz a1 n |
Std.DTreeMap.Internal.Impl.link!._unary.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k)
(motive :
(_ : Std.DTreeMap.Internal.Impl α β) ×' Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (r : Std.DTreeMap.Internal.Impl α β),
motive ⟨Std.DTreeMap.Internal.Impl.leaf, r⟩ (Std.DTreeMap.Internal.Impl.insertMin! k v r)) →
(∀ (sz' : ℕ) (k' : α) (v' : β k') (l'' r'' : Std.DTreeMap.Internal.Impl α β),
motive ⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'', Std.DTreeMap.Internal.Impl.leaf⟩
(Std.DTreeMap.Internal.Impl.insertMax! k v (Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r''))) →
(∀ (sz' : ℕ) (k' : α) (v' : β k') (l'' r'' : Std.DTreeMap.Internal.Impl α β) (sz'_1 : ℕ) (k'_1 : α)
(v'_1 : β k'_1) (l''_1 r''_1 : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.delta * sz' < sz'_1 →
motive ⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'', l''_1⟩
(Std.DTreeMap.Internal.Impl.link!._unary k v
⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'', l''_1⟩) →
motive
⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'',
Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩
(Std.DTreeMap.Internal.Impl.balanceL! k'_1 v'_1
(Std.DTreeMap.Internal.Impl.link!._unary k v
⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'', l''_1⟩)
r''_1)) →
(∀ (sz' : ℕ) (k' : α) (v' : β k') (l'' r'' : Std.DTreeMap.Internal.Impl α β) (sz'_1 : ℕ) (k'_1 : α)
(v'_1 : β k'_1) (l''_1 r''_1 : Std.DTreeMap.Internal.Impl α β),
¬Std.DTreeMap.Internal.delta * sz' < sz'_1 →
Std.DTreeMap.Internal.delta * sz'_1 < sz' →
motive ⟨r'', Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩
(Std.DTreeMap.Internal.Impl.link!._unary k v
⟨r'', Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩) →
motive
⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'',
Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩
(Std.DTreeMap.Internal.Impl.balanceR! k' v' l''
(Std.DTreeMap.Internal.Impl.link!._unary k v
⟨r'', Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩))) →
(∀ (sz' : ℕ) (k' : α) (v' : β k') (l'' r'' : Std.DTreeMap.Internal.Impl α β) (sz'_1 : ℕ) (k'_1 : α)
(v'_1 : β k'_1) (l''_1 r''_1 : Std.DTreeMap.Internal.Impl α β),
¬Std.DTreeMap.Internal.delta * sz' < sz'_1 →
¬Std.DTreeMap.Internal.delta * sz'_1 < sz' →
motive
⟨Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'',
Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1⟩
(Std.DTreeMap.Internal.Impl.inner
((Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'').size + 1 +
(Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1).size)
k v (Std.DTreeMap.Internal.Impl.inner sz' k' v' l'' r'')
(Std.DTreeMap.Internal.Impl.inner sz'_1 k'_1 v'_1 l''_1 r''_1))) →
∀ (_x : (_ : Std.DTreeMap.Internal.Impl α β) ×' Std.DTreeMap.Internal.Impl α β),
motive _x (Std.DTreeMap.Internal.Impl.link!._unary k v _x) |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.ExcenterExists.touchpoint_ne_point._simp_1_8 | Mathlib.Geometry.Euclidean.Incenter | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) |
Lean.pp.analyze.trustOfNat | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Option Bool |
Std.Ric.le_upper_of_mem | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} {r : Std.Ric α} {a : α} [inst : LE α] [LT α], a ∈ r → a ≤ r.upper |
IsSeparatedMap.pullback | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Sort u_2} {A : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace A] {f : X → Y},
IsSeparatedMap f → ∀ (g : A → Y), IsSeparatedMap Function.Pullback.snd |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion._sparseCasesOn_1 | Lean.Meta.LazyDiscrTree | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
UniformOnFun.instPseudoEMetricSpace._proof_4 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_2} {β : Type u_1} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖]
(f₁ f₂ f₃ : UniformOnFun α β 𝔖), edist f₁ f₃ ≤ edist f₁ f₂ + edist f₂ f₃ |
Polynomial.comp.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R), p.comp q = Polynomial.eval₂ Polynomial.C q p |
Lean.mkAndN._sunfold | Lean.Expr | List Lean.Expr → Lean.Expr |
Int8.toInt.eq_1 | Init.Data.SInt.Lemmas | ∀ (i : Int8), i.toInt = i.toBitVec.toInt |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {m a : ℕ}, a ≤ m → SimplexCategoryGenRel.IsAdmissible m [a] |
CategoryTheory.ShortComplex.rightHomology_ext | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology] {A : C} (f₁ f₂ : A ⟶ S.rightHomology),
CategoryTheory.CategoryStruct.comp f₁ S.rightHomologyι = CategoryTheory.CategoryStruct.comp f₂ S.rightHomologyι →
f₁ = f₂ |
seqCompactSpace_iff | Mathlib.Topology.Defs.Sequences | ∀ (X : Type u_1) [inst : TopologicalSpace X], SeqCompactSpace X ↔ IsSeqCompact Set.univ |
Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.CommRing.DiseqCnstr} →
t = t' → Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusionType P t t' |
Lean.JsonRpc.instInhabitedMessageDirection | Lean.Data.JsonRpc | Inhabited Lean.JsonRpc.MessageDirection |
Real.HolderConjugate.div_conj_eq_sub_one | Mathlib.Data.Real.ConjExponents | ∀ {p q : ℝ}, p.HolderConjugate q → p / q = p - 1 |
IntermediateField.relrank_dvd_of_le_left | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E}
(C : IntermediateField F E), A ≤ B → B.relrank C ∣ A.relrank C |
AffineMap.pi_ext_nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V2 : Type u_5} {P2 : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V2] [inst_2 : AddTorsor V2 P2]
[inst_3 : Module k V2] {ι : Type u_9} {φv : ι → Type u_10} [inst_4 : (i : ι) → AddCommGroup (φv i)]
[inst_5 : (i : ι) → Module k (φv i)] [Finite ι] [inst_7 : DecidableEq ι] {f g : ((i : ι) → φv i) →ᵃ[k] P2}
[Nonempty ι], (∀ (i : ι) (x : φv i), f (Pi.single i x) = g (Pi.single i x)) → f = g |
Std.DHashMap.Raw.Const.equiv_of_beq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
[inst_3 : BEq β] [LawfulBEq β], m₁.WF → m₂.WF → Std.DHashMap.Raw.Const.beq m₁ m₂ = true → m₁.Equiv m₂ |
RootPairing.rec | Mathlib.LinearAlgebra.RootSystem.Defs | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{motive : RootPairing ι R M N → Sort u} →
((toLinearMap : M →ₗ[R] N →ₗ[R] R) →
[isPerfPair_toLinearMap : toLinearMap.IsPerfPair] →
(root : ι ↪ M) →
(coroot : ι ↪ N) →
(root_coroot_two : ∀ (i : ι), (toLinearMap (root i)) (coroot i) = 2) →
(reflectionPerm : ι → ι ≃ ι) →
(reflectionPerm_root :
∀ (i j : ι),
root j - (toLinearMap (root j)) (coroot i) • root i =
root ((reflectionPerm i) j)) →
(reflectionPerm_coroot :
∀ (i j : ι),
coroot j - (toLinearMap (root i)) (coroot j) • coroot i =
coroot ((reflectionPerm i) j)) →
motive
{ toLinearMap := toLinearMap, isPerfPair_toLinearMap := isPerfPair_toLinearMap,
root := root, coroot := coroot, root_coroot_two := root_coroot_two,
reflectionPerm := reflectionPerm, reflectionPerm_root := reflectionPerm_root,
reflectionPerm_coroot := reflectionPerm_coroot }) →
(t : RootPairing ι R M N) → motive t |
MeasurableEquiv.prodCongr.eq_1 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] [inst_3 : MeasurableSpace δ] (ab : α ≃ᵐ β) (cd : γ ≃ᵐ δ),
ab.prodCongr cd = { toEquiv := ab.prodCongr cd.toEquiv, measurable_toFun := ⋯, measurable_invFun := ⋯ } |
RingCon.instCompleteLattice._proof_2 | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (c d : RingCon R) {w x y z : R},
(c.toSetoid ⊓ d.toSetoid) w x →
(c.toSetoid ⊓ d.toSetoid) y z → c.toSetoid (w * y) (x * z) ∧ d.toSetoid (w * y) (x * z) |
SSet.IsStrictSegal.mk | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet}, (∀ (n : ℕ), Function.Bijective (X.spine n)) → X.IsStrictSegal |
SSet.StrictSegalCore.concat | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} →
{n : ℕ} →
X.StrictSegalCore n →
(x : X.obj (Opposite.op (SimplexCategory.mk 1))) →
(s : X.obj (Opposite.op (SimplexCategory.mk n))) →
CategoryTheory.SimplicialObject.δ X 0 x = X.map ((SimplexCategory.mk 0).const (SimplexCategory.mk n) 0).op s →
X.obj (Opposite.op (SimplexCategory.mk (n + 1))) |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.rec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context → Sort u} →
((knowsType knowsLevel inBottomUp parentIsApp : Bool) →
(subExpr : Lean.SubExpr) →
motive
{ knowsType := knowsType, knowsLevel := knowsLevel, inBottomUp := inBottomUp, parentIsApp := parentIsApp,
subExpr := subExpr }) →
(t : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context) → motive t |
_private.Mathlib.FieldTheory.KrullTopology.0.IntermediateField.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.KrullTopology | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
(x ∈ Subgroup.comap f K) = (f x ∈ K) |
Aesop.Nanos.instDecidableRelLt | Aesop.Nanos | DecidableRel fun x1 x2 => x1 < x2 |
one_add_mul_le_pow' | Mathlib.Algebra.Order.Ring.Pow | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {a : R},
0 ≤ a * a → 0 ≤ (1 + a) * (1 + a) → 0 ≤ 2 + a → ∀ (n : ℕ), 1 + ↑n * a ≤ (1 + a) ^ n |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.