name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Homeomorph.inv₀._proof_2 | Mathlib.Topology.Algebra.GroupWithZero | ∀ (G₀ : Type u_1) [inst : GroupWithZero G₀] (g : { g // g ≠ 0 }), (↑g)⁻¹ ≠ 0 |
ReflBEq.casesOn | Init.Core | {α : Type u_1} →
[inst : BEq α] →
{motive : ReflBEq α → Sort u} → (t : ReflBEq α) → ((rfl : ∀ {a : α}, (a == a) = true) → motive ⋯) → motive t |
cuspFunction_mul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f g : UpperHalfPlane → ℂ},
ContinuousAt (SlashInvariantFormClass.cuspFunction h f) 0 →
ContinuousAt (SlashInvariantFormClass.cuspFunction h g) 0 →
SlashInvariantFormClass.cuspFunction h (f * g) =
SlashInvariantFormClass.cuspFunction h f * SlashInvariantFormClass.cuspFunction h g |
Units.coe_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α], ↑(-1) = -1 |
AddCommGrpCat.Hom.rec | Mathlib.Algebra.Category.Grp.Basic | {A B : AddCommGrpCat} →
{motive : A.Hom B → Sort u_1} → ((hom' : ↑A →+ ↑B) → motive { hom' := hom' }) → (t : A.Hom B) → motive t |
Tactic.ComputeAsymptotics.Seq.FriendlyOperation.ite | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} {op₁ op₂ : Stream'.Seq α → Stream'.Seq α},
Tactic.ComputeAsymptotics.Seq.FriendlyOperation op₁ →
Tactic.ComputeAsymptotics.Seq.FriendlyOperation op₂ →
∀ {P : Option α → Prop} [inst : DecidablePred P],
Tactic.ComputeAsymptotics.Seq.FriendlyOperation fun s => if P s.head then op₁ s else op₂ s |
AddCommGroup.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ (n : ℕ), NeZero (n + 1) |
LocallyConstant.toContinuousMapLinearMap_apply | Mathlib.Topology.ContinuousMap.LocallyConstant | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (R : Type u_3)
[inst_2 : Semiring R] [inst_3 : AddCommMonoid Y] [inst_4 : Module R Y] [inst_5 : ContinuousAdd Y]
[inst_6 : ContinuousConstSMul R Y] (f : LocallyConstant X Y), (LocallyConstant.toContinuousMapLinearMap R) f = ↑f |
NumberField.integralBasis_apply | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(i : Module.Free.ChooseBasisIndex ℤ (NumberField.RingOfIntegers K)),
(NumberField.integralBasis K) i =
(algebraMap (NumberField.RingOfIntegers K) K) ((NumberField.RingOfIntegers.basis K) i) |
Std.Tactic.BVDecide.LRAT.Internal.Formula.sat_iff_forall | Std.Tactic.BVDecide.LRAT.Internal.CNF | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β]
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] [inst_2 : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(p : α → Bool) (f : σ),
Std.Tactic.BVDecide.LRAT.Internal.Entails.eval p f ↔
∀ c ∈ Std.Tactic.BVDecide.LRAT.Internal.Formula.toList f, Std.Tactic.BVDecide.LRAT.Internal.Entails.eval p c |
Height.mulHeight₁_pos | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x : K), 0 < Height.mulHeight₁ x |
Real.continuous_arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | Continuous Real.arsinh |
TensorialAt.mkHom._proof_5 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {M : Type u_4} [inst_1 : TopologicalSpace M] {F : Type u_3}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] {V : M → Type u_2}
[inst_4 : TopologicalSpace (Bundle.TotalSpace F V)] [inst_5 : (x : M) → AddCommGroup (V x)]
[inst_6 : (x : M) → Module 𝕜 (V x)] [inst_7 : (x : M) → TopologicalSpace (V x)] [inst_8 : FiberBundle F V]
[VectorBundle 𝕜 F V] (x : M), ContinuousSMul 𝕜 (V x) |
_private.Init.Data.String.Basic.0.String.Slice.Pos.copy._proof_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos), String.Pos.Raw.IsValid s.copy pos.offset |
HurwitzZeta.differentiableAt_completedCosZeta | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle) {s : ℂ}, s ≠ 0 → s ≠ 1 ∨ a ≠ 0 → DifferentiableAt ℂ (HurwitzZeta.completedCosZeta a) s |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.mulLeftMono.match_3 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (α : Type u_1) (r : α → α → Prop) (wo : IsWellOrder α r)
(motive : (x : WellOrder) → ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦x⟧ → Prop) (x : WellOrder)
(x_1 : ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦x⟧),
(∀ (β : Type u_1) (s : β → β → Prop) (wo_1 : IsWellOrder β s)
(x : ⟦{ α := α, r := r, wo := wo }⟧ ≤ ⟦{ α := β, r := s, wo := wo_1 }⟧),
motive { α := β, r := s, wo := wo_1 } x) →
motive x x_1 |
CalcParams.indent | Mathlib.Tactic.Widget.Calc | CalcParams → ℕ |
Congr!.Config.closePost | Mathlib.Tactic.CongrExclamation | Congr!.Config → Bool |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._proof_15 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_2} {L : Type u_4} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing M] [inst_4 : LieAlgebra R M] (E : LieAlgebra.Extension R M L) {s : L →ₗ[R] E.L}
(hs : Function.LeftInverse ⇑E.proj ⇑s) (x : R) (x_1 x_2 x_3 : L),
⟨⁅s (x • x_1), s (x_2 + x_3)⁆ - s ⁅x • x_1, x_2 + x_3⁆, ⋯⟩ =
⟨⁅s (x • x_1), s x_2⁆ - s ⁅x • x_1, x_2⁆, ⋯⟩ + ⟨⁅s (x • x_1), s x_3⁆ - s ⁅x • x_1, x_3⁆, ⋯⟩ |
MonotoneOn.intervalIntegrable_slope | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {f : ℝ → ℝ} {a b c : ℝ},
MonotoneOn f (Set.Icc a (b + c)) →
a ≤ b → 0 ≤ c → IntervalIntegrable (fun x => slope f x (x + c)) MeasureTheory.volume a b |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.mk.inj | Lean.Elab.Tactic.Induction | ∀ {view : Lean.Elab.Tactic.ElimTargetView} {expr : Lean.Expr} {arg? : Option Lean.Meta.GeneralizeArg}
{view_1 : Lean.Elab.Tactic.ElimTargetView} {expr_1 : Lean.Expr} {arg?_1 : Option Lean.Meta.GeneralizeArg},
{ view := view, expr := expr, arg? := arg? } = { view := view_1, expr := expr_1, arg? := arg?_1 } →
view = view_1 ∧ expr = expr_1 ∧ arg? = arg?_1 |
MeasureTheory.laverage_const | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ] [h : NeZero μ]
(c : ENNReal), ⨍⁻ (_x : α), c ∂μ = c |
_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.maybeProveInjective.match_1 | Mathlib.Tactic.ApplyFun | (motive : Option Lean.Expr → Sort u_1) →
(using? : Option Lean.Expr) →
((u : Lean.Expr) → motive (some u)) → ((x : Option Lean.Expr) → motive x) → motive using? |
eq_of_forall_symmetric | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} [inst : UniformSpace α] [T0Space α] {x y : α},
(∀ {V : Set (α × α)}, V ∈ uniformity α → SetRel.IsSymm V → (x, y) ∈ V) → x = y |
Set.countable_setOf_nonempty_of_disjoint | Mathlib.Data.Set.Countable | ∀ {α : Type u} {β : Type v} {f : β → Set α},
Pairwise (Function.onFun Disjoint f) →
∀ {s : Set α}, (∀ (t : β), f t ⊆ s) → s.Countable → {t | (f t).Nonempty}.Countable |
CategoryTheory.ShortComplex.LeftHomologyData.ofAbelian._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.lift S.g S.f ⋯)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel.π S.f)) =
0 |
Matrix.kroneckerStarAlgEquiv._proof_1 | Mathlib.RingTheory.MatrixAlgebra | ∀ (m : Type u_1) (n : Type u_2) (R : Type u_3) [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] [inst_5 : StarRing R],
(Matrix.kroneckerAlgEquiv m n R) (star 0) = star ((Matrix.kroneckerAlgEquiv m n R) 0) |
IO.Error.unsatisfiedConstraints.inj | Init.System.IOError | ∀ {osCode : UInt32} {details : String} {osCode_1 : UInt32} {details_1 : String},
IO.Error.unsatisfiedConstraints osCode details = IO.Error.unsatisfiedConstraints osCode_1 details_1 →
osCode = osCode_1 ∧ details = details_1 |
Lean.Elab.Term.instInhabitedArg | Lean.Elab.Arg | Inhabited Lean.Elab.Term.Arg |
Nat.finMulAntidiag_one | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {d : ℕ}, d.finMulAntidiag 1 = {fun x => 1} |
CategoryTheory.MorphismProperty.LeftFractionRel.op | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
{z₁ z₂ : W.LeftFraction X Y},
CategoryTheory.MorphismProperty.LeftFractionRel z₁ z₂ → CategoryTheory.MorphismProperty.RightFractionRel z₁.op z₂.op |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVExpr.PackedBitVec → Std.Tactic.BVDecide.BVExpr.PackedBitVec → Sort u |
Std.HashMap.contains_insert_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, (m.insert k v).contains k = true |
Std.OrientedCmp.not_isLE_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.lt → ¬(cmp b a).isLE = true |
DFinsupp.sumAddHom | Mathlib.Data.DFinsupp.BigOperators | {ι : Type u} →
{γ : Type w} →
{β : ι → Type v} →
[DecidableEq ι] →
[inst : (i : ι) → AddZeroClass (β i)] →
[inst_1 : AddCommMonoid γ] → ((i : ι) → β i →+ γ) → (Π₀ (i : ι), β i) →+ γ |
Lean.ForEachExprWhere.ForEachM | Lean.Util.ForEachExprWhere | {ω : Type} → (m : Type → Type) → [STWorld ω m] → Type → Type |
RightCancelMonoid.pow_eq_pow_iff_modEq | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {x : G} {m n : ℕ}, x ^ n = x ^ m ↔ n ≡ m [MOD orderOf x] |
_private.Mathlib.Algebra.CharP.Defs.0.CharP.char_is_prime_or_zero.match_1_1 | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : NonAssocSemiring R] (motive : (p : ℕ) → CharP R p → Prop) (p : ℕ) (hc : CharP R p),
(∀ (x : CharP R 0), motive 0 x) →
(∀ (hc : CharP R 1), motive 1 hc) → (∀ (m : ℕ) (hc : CharP R (m + 2)), motive m.succ.succ hc) → motive p hc |
Rep.quotientToCoinvariantsFunctor._proof_5 | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal]
(X : Rep k G),
{
hom :=
(Rep.coinvariantsFunctor k ↥S).map
((Action.res (ModuleCat k) S.subtype).map (CategoryTheory.CategoryStruct.id X)),
comm := ⋯ } =
CategoryTheory.CategoryStruct.id (X.quotientToCoinvariants S) |
MeasureTheory.eventually_sub_right_iff | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (t : G) {p : G → Prop}, (∀ᵐ (x : G) ∂μ, p (x - t)) ↔ ∀ᵐ (x : G) ∂μ, p x |
AlternatingMap.map_basis_eq_zero_iff | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_5}
[Finite ι] (e : Module.Basis ι R M) (f : M [⋀^ι]→ₗ[R] R), f ⇑e = 0 ↔ f = 0 |
CategoryTheory.ShortComplex.Exact.moduleCat_of_range_eq_ker._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] {X₁ X₂ X₃ : ModuleCat R} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
(ModuleCat.Hom.hom f).range = (ModuleCat.Hom.hom g).ker → (ModuleCat.Hom.hom f).range ≤ (ModuleCat.Hom.hom g).ker |
Std.Time.instHAddOffsetOffset_8 | Std.Time.Date.Basic | HAdd Std.Time.Millisecond.Offset Std.Time.Minute.Offset Std.Time.Millisecond.Offset |
Filter.map_neg' | Mathlib.Order.Filter.Pointwise | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : SubtractionMonoid β]
[inst_2 : FunLike F α β] [AddMonoidHomClass F α β] (m : F) {f : Filter α}, Filter.map (⇑m) (-f) = -Filter.map (⇑m) f |
Asymptotics.isBigOWith_map | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E}
{g : α → F} {k : β → α} {l : Filter β},
Asymptotics.IsBigOWith c (Filter.map k l) f g ↔ Asymptotics.IsBigOWith c l (f ∘ k) (g ∘ k) |
Matroid.IsColoop.insert_indep_of_indep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.IsColoop e → M.Indep I → M.Indep (insert e I) |
integrableOn_Ico_iff_integrableOn_Ioo'._auto_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | Lean.Syntax |
Filter.Germ.instMulZeroClass._proof_2 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {R : Type u_2} [inst : MulZeroClass R] (q : Quotient (l.germSetoid R)), q * 0 = 0 |
AddSubmonoidClass.finsuppSum_mem | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] {S : Type u_16}
[inst_2 : SetLike S N] [AddSubmonoidClass S N] (s : S) (f : α →₀ M) (g : α → M → N),
(∀ (c : α), f c ≠ 0 → g c (f c) ∈ s) → f.sum g ∈ s |
CategoryTheory.Functor.CommShift.isoZero | Mathlib.CategoryTheory.Shift.CommShift | {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) →
(A : Type u_4) →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheory.HasShift C A] →
[inst_4 : CategoryTheory.HasShift D A] →
(CategoryTheory.shiftFunctor C 0).comp F ≅ F.comp (CategoryTheory.shiftFunctor D 0) |
SkewMonoidAlgebra.of._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ (k : Type u_1) (G : Type u_2) [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] (a b : G),
SkewMonoidAlgebra.single (a * b) 1 = SkewMonoidAlgebra.single a 1 * SkewMonoidAlgebra.single b 1 |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.Fintype.not_linearIndependent_iffₒₛ._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_ae_parallelepiped._simp_1_4 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ico a b) = (a ≤ x ∧ x < b) |
StrictAnti.not_bddBelow_range_of_isPredArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [Nonempty α] [inst_2 : Preorder β] {f : α → β} [NoMaxOrder α]
[inst_4 : PredOrder β] [IsPredArchimedean β], StrictAnti f → ¬BddBelow (Set.range f) |
Units.eq_inv_of_mul_eq_one_right | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, a * ↑u = 1 → a = ↑u⁻¹ |
Std.ExtTreeMap.maxKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' |
SchwartzMap.instAddCommGroup | 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] → AddCommGroup (SchwartzMap E F) |
PFun.prodLift_fst_comp_snd_comp | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α →. γ) (g : β →. δ),
(f.comp ↑Prod.fst).prodLift (g.comp ↑Prod.snd) = f.prodMap g |
Complex.cos_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℕ), Complex.cos (x + ↑n * (2 * ↑Real.pi)) = Complex.cos x |
instSemilatticeSupSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_2 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (a b : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }),
((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2).1 * ((↑a).1 + (↑a).2 * (↑b).1, (↑a).2 * (↑b).2).2 = 0 |
Aesop.instEmptyCollectionLocalRuleSet | Aesop.RuleSet | EmptyCollection Aesop.LocalRuleSet |
Lean.Lsp.InlayHintLabel.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintLabel → Sort u} → ℕ → Sort (max 1 u) |
PositiveLinearMap.toLinearMap_nsmul | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] [inst_7 : IsOrderedAddMonoid E₂] (f : E₁ →ₚ[R] E₂) (n : ℕ),
(n • f).toLinearMap = n • f.toLinearMap |
MeasureTheory.lpTrimToLpMeasSubgroup_ae_eq | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) (f : ↥(MeasureTheory.Lp F p (μ.trim hm))),
↑↑↑(MeasureTheory.lpTrimToLpMeasSubgroup F p μ hm f) =ᵐ[μ] ↑↑f |
Lean.Omega.Constraint.instToString._private_1 | Init.Omega.Constraint | Lean.Omega.Constraint → String |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_7 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (0 ≤ a - b) = (b ≤ a) |
Lean.Elab.Tactic.DiscrTreeKey.evalDiscrTreeSimpKeyCmd | Lean.Elab.Tactic.DiscrTreeKey | Lean.Elab.Command.CommandElab |
Std.TreeMap.maxKey! | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited α] → Std.TreeMap α β cmp → α |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.kfSc_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax |
Lean.Elab.Tactic.Conv.PatternMatchState.all.inj | Lean.Elab.Tactic.Conv.Pattern | ∀ {subgoals subgoals_1 : Array Lean.MVarId},
Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals = Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals_1 →
subgoals = subgoals_1 |
List.mapAsyncChunked | Mathlib.Data.List.Defs | {α : Type u_7} → {β : Type u_8} → (α → β) → List α → optParam ℕ 1024 → List β |
CategoryTheory.Functor.comp_mapGrp_mul | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{E : Type u₃} [inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.CartesianMonoidalCategory E]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D E} [inst_6 : F.Monoidal] [inst_7 : G.Monoidal]
(A : CategoryTheory.Grp C),
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ (F.comp G) A.X A.X)
((F.comp G).map CategoryTheory.MonObj.mul) |
Perfection.coeff | Mathlib.RingTheory.Perfection | (R : Type u_1) →
[inst : CommSemiring R] → (p : ℕ) → [hp : Fact (Nat.Prime p)] → [inst_1 : CharP R p] → ℕ → Perfection R p →+* R |
Subgroup.div_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x y : G}, x ∈ H → y ∈ H → x / y ∈ H |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?.match_8 | Lean.Meta.Tactic.Grind.PropagateInj | (motive : Option Lean.Meta.Grind.InjectiveInfo → Sort u_1) →
(x : Option Lean.Meta.Grind.InjectiveInfo) →
((info : Lean.Meta.Grind.InjectiveInfo) → motive (some info)) →
((x : Option Lean.Meta.Grind.InjectiveInfo) → motive x) → motive x |
existsUnique_eq' | Mathlib.Logic.ExistsUnique | ∀ {α : Sort u_1} {a' : α}, ∃! a, a' = a |
FirstOrder.Language.Relations.transitive._proof_1 | Mathlib.ModelTheory.Syntax | NeZero (0 + 1 + 1 + 1) |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | SizeOf Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof |
_private.Mathlib.GroupTheory.Perm.Cycle.Concrete.0.Cycle.formPerm_subsingleton._simp_1_5 | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (a ≤ 0) = (a = 0) |
Nat.toInt8 | Init.Data.SInt.Basic | ℕ → Int8 |
_private.Mathlib.FieldTheory.Isaacs.0.Field.nonempty_algEquiv_of_aeval_eq_zero_eq.match_1_1 | Mathlib.FieldTheory.Isaacs | ∀ {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] (motive : Nonempty (K →ₐ[F] E) → Prop) (x : Nonempty (K →ₐ[F] E)),
(∀ (τ : K →ₐ[F] E), motive ⋯) → motive x |
CategoryTheory.Comma.mapLeft.eq_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂),
CategoryTheory.Comma.mapLeft R l =
{
obj := fun X =>
{ left := X.left, right := X.right, hom := CategoryTheory.CategoryStruct.comp (l.app X.left) X.hom },
map := fun {X Y} f => { left := f.left, right := f.right, w := ⋯ }, map_id := ⋯, map_comp := ⋯ } |
AddSubmonoid.mem_multiples_iff | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] (x z : M), x ∈ AddSubmonoid.multiples z ↔ ∃ n, n • z = x |
Lean.IR.NormalizeIds.normJP | Lean.Compiler.IR.NormIds | Lean.IR.JoinPointId → Lean.IR.NormalizeIds.M Lean.IR.JoinPointId |
Lean.Compiler.LCNF.ExtractClosed.shouldExtractFVar | Lean.Compiler.LCNF.ExtractClosed | Lean.FVarId → Lean.Compiler.LCNF.ExtractClosed.M Bool |
Nat.length_toList_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {b : ℕ}, (*...b).toList.length = b |
_private.Init.Data.String.Slice.0.String.Slice.SplitInclusiveIterator.instIteratorId.match_1.eq_5 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice}
(motive : Std.IterM Id String.Slice → Std.IterStep (Std.IterM Id String.Slice) String.Slice → Sort u_1)
(currPos : s.Pos) (s_1 : Std.Iter (String.Slice.Pattern.SearchStep s))
(h_1 :
(currPos : s.Pos) →
(s_2 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
(currPos_1 : s.Pos) →
(s' : Std.Iter (String.Slice.Pattern.SearchStep s)) →
(out : String.Slice) →
motive { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 }
(Std.IterStep.yield { internalState := String.Slice.SplitInclusiveIterator.operating currPos_1 s' }
out))
(h_2 :
(currPos : s.Pos) →
(s_2 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
(out : String.Slice) →
motive { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 }
(Std.IterStep.yield { internalState := String.Slice.SplitInclusiveIterator.atEnd } out))
(h_3 :
(currPos : s.Pos) →
(s_2 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
(currPos_1 : s.Pos) →
(s' : Std.Iter (String.Slice.Pattern.SearchStep s)) →
motive { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 }
(Std.IterStep.skip { internalState := String.Slice.SplitInclusiveIterator.operating currPos_1 s' }))
(h_4 :
(currPos : s.Pos) →
(s_2 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
motive { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 }
(Std.IterStep.skip { internalState := String.Slice.SplitInclusiveIterator.atEnd }))
(h_5 :
(currPos : s.Pos) →
(s_2 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
motive { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 } Std.IterStep.done)
(h_6 :
(it : Std.IterM Id String.Slice) →
(out : String.Slice) →
motive { internalState := String.Slice.SplitInclusiveIterator.atEnd } (Std.IterStep.yield it out))
(h_7 :
(it : Std.IterM Id String.Slice) →
motive { internalState := String.Slice.SplitInclusiveIterator.atEnd } (Std.IterStep.skip it))
(h_8 : Unit → motive { internalState := String.Slice.SplitInclusiveIterator.atEnd } Std.IterStep.done),
(match { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_1 }, Std.IterStep.done with
| { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 },
Std.IterStep.yield { internalState := String.Slice.SplitInclusiveIterator.operating currPos_1 s' } out =>
h_1 currPos s_2 currPos_1 s' out
| { internalState := String.Slice.SplitInclusiveIterator.operating currPos s },
Std.IterStep.yield { internalState := String.Slice.SplitInclusiveIterator.atEnd } out => h_2 currPos s out
| { internalState := String.Slice.SplitInclusiveIterator.operating currPos s_2 },
Std.IterStep.skip { internalState := String.Slice.SplitInclusiveIterator.operating currPos_1 s' } =>
h_3 currPos s_2 currPos_1 s'
| { internalState := String.Slice.SplitInclusiveIterator.operating currPos s },
Std.IterStep.skip { internalState := String.Slice.SplitInclusiveIterator.atEnd } => h_4 currPos s
| { internalState := String.Slice.SplitInclusiveIterator.operating currPos s }, Std.IterStep.done => h_5 currPos s
| { internalState := String.Slice.SplitInclusiveIterator.atEnd }, Std.IterStep.yield it out => h_6 it out
| { internalState := String.Slice.SplitInclusiveIterator.atEnd }, Std.IterStep.skip it => h_7 it
| { internalState := String.Slice.SplitInclusiveIterator.atEnd }, Std.IterStep.done => h_8 ()) =
h_5 currPos s_1 |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.length_bypass_le._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} [inst : DecidableEq V] {v w : V} (p : G.Walk v w),
p.bypass.length ≤ p.length → p.bypass.length ≤ p.length + 1 |
Diffeomorph.prodComm_symm | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_7} [inst_6 : TopologicalSpace G] (I : ModelWithCorners 𝕜 E H)
(J : ModelWithCorners 𝕜 F G) (M : Type u_9) [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M] (N : Type u_11)
[inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] (n : WithTop ℕ∞),
(Diffeomorph.prodComm I J M N n).symm = Diffeomorph.prodComm J I N M n |
_private.Mathlib.Logic.Nonempty.0.nonempty_pprod.match_1_3 | Mathlib.Logic.Nonempty | ∀ {α : Sort u_1} {β : Sort u_2} (motive : Nonempty α ∧ Nonempty β → Prop) (x : Nonempty α ∧ Nonempty β),
(∀ (a : α) (b : β), motive ⋯) → motive x |
_private.Init.Data.String.Termination.0.String.Pos.remainingBytes_inj._simp_1_1 | Init.Data.String.Termination | ∀ {s : String} {p : s.Pos}, p.remainingBytes = p.toSlice.remainingBytes |
Lean.Meta.LibrarySearch.DeclMod.mp | Lean.Meta.Tactic.LibrarySearch | Lean.Meta.LibrarySearch.DeclMod |
Lean.Widget.MsgEmbed.rec_2 | Lean.Widget.InteractiveDiagnostic | {motive_1 : Lean.Widget.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u} →
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u} →
{motive_4 : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u} →
{motive_5 : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed) → Sort u} →
((a : Lean.Widget.CodeWithInfos) → motive_1 (Lean.Widget.MsgEmbed.expr a)) →
((a : Lean.Widget.InteractiveGoal) → motive_1 (Lean.Widget.MsgEmbed.goal a)) →
((wi : Lean.Widget.WidgetInstance) →
(alt : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) →
motive_2 alt → motive_1 (Lean.Widget.MsgEmbed.widget wi alt)) →
((indent : ℕ) →
(cls : Lean.Name) →
(msg : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) →
(collapsed : Bool) →
(children :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) →
motive_2 msg →
motive_3 children →
motive_1 (Lean.Widget.MsgEmbed.trace indent cls msg collapsed children)) →
((a : String) → motive_2 (Lean.Widget.TaggedText.text a)) →
((a : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
motive_4 a → motive_2 (Lean.Widget.TaggedText.append a)) →
((a : Lean.Widget.MsgEmbed) →
(a_1 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) →
motive_1 a → motive_2 a_1 → motive_2 (Lean.Widget.TaggedText.tag a a_1)) →
((a : Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
motive_4 a → motive_3 (Lean.Widget.StrictOrLazy.strict a)) →
((a : Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
motive_3 (Lean.Widget.StrictOrLazy.lazy a)) →
((toList : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
motive_5 toList → motive_4 { toList := toList }) →
motive_5 [] →
((head : Lean.Widget.TaggedText Lean.Widget.MsgEmbed) →
(tail : List (Lean.Widget.TaggedText Lean.Widget.MsgEmbed)) →
motive_2 head → motive_5 tail → motive_5 (head :: tail)) →
(t :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren)) →
motive_3 t |
stdSimplex.map | Mathlib.Analysis.Convex.StdSimplex | {S : Type u_1} →
[inst : Semiring S] →
[inst_1 : PartialOrder S] →
{X : Type u_2} →
{Y : Type u_3} →
[inst_2 : Fintype X] →
[inst_3 : Fintype Y] → [IsOrderedRing S] → (X → Y) → ↑(stdSimplex S X) → ↑(stdSimplex S Y) |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.δ_rightShift._proof_1_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n : ℤ} (a n' m' : ℤ), n' + a = n → ∀ (m : ℤ), m' + a = m → n + 1 = m → ∀ (p q : ℤ), p + m' = q → p + n' = q - 1 |
TopCat.continuousFunctions.pullback._proof_4 | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X Y : TopCatᵒᵖ} (f : X ⟶ Y) (R : TopCommRingCat),
CategoryTheory.CategoryStruct.comp f.unop 0 = CategoryTheory.CategoryStruct.comp f.unop 0 |
Equiv.optionSubtypeNe_symm_apply | Mathlib.Logic.Equiv.Option | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α),
(Equiv.optionSubtypeNe a).symm b = if h : b = a then none else some ⟨b, h⟩ |
Real.two_pi_pos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | 0 < 2 * Real.pi |
Nat.sub_lt_right_of_lt_add | Init.Data.Nat.Basic | ∀ {n k m : ℕ}, n ≤ k → k < m + n → k - n < m |
DirectSum.IsInternal.coeAlgEquiv | Mathlib.RingTheory.GradedAlgebra.Basic | {R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{ι : Type u_7} →
[inst_3 : DecidableEq ι] →
[inst_4 : AddMonoid ι] →
{M : ι → Submodule R A} →
[inst_5 : SetLike.GradedMonoid M] → DirectSum.IsInternal M → (DirectSum ι fun i => ↥(M i)) ≃ₐ[R] A |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.