name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Meta.withLetDecl | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Lean.Name →
Lean.Expr →
Lean.Expr →
(Lean.Expr → n α) → optParam Bool false → optParam Lean.LocalDeclKind Lean.LocalDeclKind.default → n α |
InnerProductGeometry.cos_angle | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
Real.cos (InnerProductGeometry.angle x y) = inner ℝ x y / (‖x‖ * ‖y‖) |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_lt_base_pow_length'._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True |
Lean.Meta.KExprMap.rec | Lean.Meta.KExprMap | {α : Type} →
{motive : Lean.Meta.KExprMap α → Sort u} →
((map : Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)) → motive { map := map }) →
(t : Lean.Meta.KExprMap α) → motive t |
WithBot.giUnbotDBot | Mathlib.Order.GaloisConnection.Basic | {α : Type u} → [inst : Preorder α] → [inst_1 : OrderBot α] → GaloisInsertion (WithBot.unbotD ⊥) WithBot.some |
Submodule.orderIsoMapComap_apply' | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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₂}
{τ₂₁ : R₂ →+* R} [inst_6 : RingHomInvPair τ₁₂ τ₂₁] [inst_7 : RingHomInvPair τ₂₁ τ₁₂] (e : M ≃ₛₗ[τ₁₂] M₂)
(p : Submodule R M), (Submodule.orderIsoMapComap e) p = Submodule.comap (↑e.symm) p |
_private.Lean.Compiler.IR.ElimDeadVars.0.Lean.IR.reshapeWithoutDead.reshape.match_1 | Lean.Compiler.IR.ElimDeadVars | (motive : Lean.IR.FnBody → Sort u_1) →
(curr : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive (Lean.IR.FnBody.jdecl j xs v b)) →
((x : Lean.IR.FnBody) → motive x) → motive curr |
Lean.ImportM.Context.noConfusionType | Lean.Environment | Sort u → Lean.ImportM.Context → Lean.ImportM.Context → Sort u |
DFinsupp.linearEquivFunOnFintype | Mathlib.LinearAlgebra.DFinsupp | {ι : Type u_1} →
{R : Type u_3} →
{M : ι → Type u_5} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → [Fintype ι] → (Π₀ (i : ι), M i) ≃ₗ[R] (i : ι) → M i |
IsStronglyCoatomic.of_wellFounded_gt | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α], (WellFounded fun x1 x2 => x1 > x2) → IsStronglyCoatomic α |
aestronglyMeasurable_iff_aemeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : MeasurableSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [BorelSpace β]
[SecondCountableTopology β], MeasureTheory.AEStronglyMeasurable f μ ↔ AEMeasurable f μ |
IsUnit.finset | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {a : α}, IsUnit a → IsUnit {a} |
contDiffWithinAt_const | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E}
{n : WithTop ℕ∞} {c : F}, ContDiffWithinAt 𝕜 n (fun x => c) s x |
Nat.cast_succ | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n.succ = ↑n + 1 |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.mkCoe.match_1 | Lean.Elab.Term.TermElabM | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((eNew : Lean.Expr) → (expandedCoeDecls : List Lean.Name) → motive (Lean.LOption.some (eNew, expandedCoeDecls))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift |
List.decidableSortedGE | Mathlib.Data.List.Sort | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → DecidablePred List.SortedGE |
SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Copy___unexpand_SimpleGraph_IsIndContained_1 | Mathlib.Combinatorics.SimpleGraph.Copy | Lean.PrettyPrinter.Unexpander |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertMany_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
apply_wcovBy_apply_iff._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {a b : α} {E : Type u_3}
[inst_2 : EquivLike E α β] [OrderIsoClass E α β] (e : E), (e a ⩿ e b) = (a ⩿ b) |
LSeries.term_sum_apply | Mathlib.NumberTheory.LSeries.Linearity | ∀ {ι : Type u_1} (f : ι → ℕ → ℂ) (S : Finset ι) (s : ℂ) (n : ℕ),
LSeries.term (∑ i ∈ S, f i) s n = ∑ i ∈ S, LSeries.term (f i) s n |
Std.TreeMap.contains_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {k : α}, ∅.contains k = false |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertMany._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} {ρ : Type u_3} [inst : ForIn Id ρ (α × β)]
(m : Std.DHashMap α fun x => β) (l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany ⟨m.inner, ⋯⟩ l)).WF |
Topology.WithLowerSet.toLowerSet_symm | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1}, Topology.WithLowerSet.toLowerSet.symm = Topology.WithLowerSet.ofLowerSet |
NonUnitalSubalgebra.iSupLift._proof_4 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {ι : Sort u_3} [Nonempty ι]
(K : ι → NonUnitalSubalgebra R A), Directed (fun x1 x2 => x1 ≤ x2) K → ↑(iSup K) ⊆ ⋃ i, ↑(K i) |
curveIntegralFun_symm | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} (ω : E → E →L[𝕜] F)
(γ : Path a b), curveIntegralFun ω γ.symm = fun x => (-curveIntegralFun ω γ) (1 - x) |
Nat.mul_ne_mul_left | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a ≠ 0 → (b * a ≠ c * a ↔ b ≠ c) |
GradedRingHom.map_one | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_6} {τ : Type u_7} [inst : Semiring A] [inst_1 : Semiring B]
[inst_2 : SetLike σ A] [inst_3 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} (f : 𝒜 →+*ᵍ ℬ), f 1 = 1 |
CategoryTheory.Bicategory.Adj.forget₁._proof_7 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} {f g : a ⟶ b}
(η : f ⟶ g) (h : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η h).τl =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp f h).l).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η.τl h.l)
(CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp g h).l).inv) |
OpenPartialHomeomorph.extend_image_nhds_mem_nhds_of_boundaryless | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} [I.Boundaryless] {x : M},
x ∈ f.source → ∀ {s : Set M}, s ∈ nhds x → ↑(f.extend I) '' s ∈ nhds (↑(f.extend I) x) |
Lean.Meta.Grind.EMatchTheoremKind.leftRight.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | sizeOf Lean.Meta.Grind.EMatchTheoremKind.leftRight = 1 |
FiniteDimensional.basisSingleton._proof_5 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], StrongRankCondition K |
MulAction.is_one_pretransitive_iff | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α],
MulAction.IsMultiplyPretransitive G α 1 ↔ MulAction.IsPretransitive G α |
ContinuousMap.inv_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Inv β]
[inst_3 : ContinuousInv β] (f : C(α, β)) (x : α), f⁻¹ x = (f x)⁻¹ |
Std.Time.Database.TZdb.inst.match_4 | Std.Time.Zoned.Database.TZdb | (motive : Option Std.Time.TimeZone.ZoneRules → Sort u_1) →
(x : Option Std.Time.TimeZone.ZoneRules) →
(Unit → motive none) → ((a : Std.Time.TimeZone.ZoneRules) → motive (some a)) → motive x |
_private.Init.Data.List.Nat.TakeDrop.0.List.take_set_of_le._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {i j : ℕ}, j ≤ i → ∀ i_1 < j, i = i_1 → False |
Lists.Subset.decidable.match_1 | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : Lists' α true → Lists' α true → Sort u_2) →
(x x_1 : Lists' α true) →
((x : Lists' α true) → motive Lists'.nil x) →
((b : Bool) → (a : Lists' α b) → (l₁ l₂ : Lists' α true) → motive (a.cons' l₁) l₂) → motive x x_1 |
Unique.rec | Mathlib.Logic.Unique | {α : Sort u} →
{motive : Unique α → Sort u_1} →
((toInhabited : Inhabited α) →
(uniq : ∀ (a : α), a = default) → motive { toInhabited := toInhabited, uniq := uniq }) →
(t : Unique α) → motive t |
List.get_length_sub_one._proof_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α}, l.length - 1 < l.length → l ≠ [] |
OrderIso.sumLexIicIoi | Mathlib.Order.Hom.Lex | {α : Type u_1} → [inst : LinearOrder α] → (x : α) → Lex (↑(Set.Iic x) ⊕ ↑(Set.Ioi x)) ≃o α |
Std.DHashMap.Internal.Raw₀.insertListₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[BEq α] → [Hashable α] → Std.DHashMap.Internal.Raw₀ α β → List ((a : α) × β a) → Std.DHashMap.Internal.Raw₀ α β |
fderiv_fun_smul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : 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] {f : E → F}
{x : E} {𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F]
[inst_8 : IsBoundedSMul 𝕜' F] [inst_9 : IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'},
DifferentiableAt 𝕜 c x →
DifferentiableAt 𝕜 f x → fderiv 𝕜 (fun y => c y • f y) x = c x • fderiv 𝕜 f x + (fderiv 𝕜 c x).smulRight (f x) |
_private.Mathlib.AlgebraicTopology.DoldKan.Normalized.0.AlgebraicTopology.DoldKan.HigherFacesVanish.inclusionOfMooreComplexMap._simp_1_1 | Mathlib.AlgebraicTopology.DoldKan.Normalized | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.IsComplex) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1)
[inst_2 : (S.sc hS k ⋯).HasRightHomology] [inst_3 : (S.sc hS (k + 1) ⋯).HasLeftHomology],
CategoryTheory.CategoryStruct.comp (S.sc hS k ⋯).pOpcycles
(CategoryTheory.CategoryStruct.comp (hS.opcyclesToCycles k ⋯) (S.sc hS (k + 1) ⋯).iCycles) =
S.map' (k + 1) (k + 2) ⋯ ⋯ |
CategoryTheory.StructuredArrow.eta_hom_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : D} {T : CategoryTheory.Functor C D} (f : CategoryTheory.StructuredArrow S T),
f.eta.hom.right = CategoryTheory.CategoryStruct.id f.right |
Real.cos_sub_nat_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.cos (x - ↑n * Real.pi) = (-1) ^ n * Real.cos x |
DFinsupp.addCommGroup._proof_7 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddCommGroup (β i)] (x : Π₀ (i : ι), β i) (x_1 : ℤ),
⇑(x_1 • x) = x_1 • ⇑x |
ProofWidgets.CheckRequestResponse.done | ProofWidgets.Cancellable | ProofWidgets.LazyEncodable Lean.Json → ProofWidgets.CheckRequestResponse |
Set.card_image_of_inj_on | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {β : Type v} {s : Set α} [inst : Fintype ↑s] {f : α → β} [inst_1 : Fintype ↑(f '' s)],
(∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y) → Fintype.card ↑(f '' s) = Fintype.card ↑s |
Lean.Environment.Replay.Context.casesOn | Lean.Replay | {motive : Lean.Environment.Replay.Context → Sort u} →
(t : Lean.Environment.Replay.Context) →
((newConstants : Std.HashMap Lean.Name Lean.ConstantInfo) → motive { newConstants := newConstants }) → motive t |
HasStrictFDerivAt.snd | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {f₂ : E → F × G} {f₂' : E →L[𝕜] F × G},
HasStrictFDerivAt f₂ f₂' x → HasStrictFDerivAt (fun x => (f₂ x).2) ((ContinuousLinearMap.snd 𝕜 F G).comp f₂') x |
Vector.set_eraseIdx._proof_2 | Init.Data.Vector.Erase | ∀ {n i : ℕ} {w : i < n} {j : ℕ}, ¬i ≤ j → j < n |
Rack.PreEnvelGroupRel'._sizeOf_inst | Mathlib.Algebra.Quandle | (R : Type u) → {inst : Rack R} → (a a_1 : Rack.PreEnvelGroup R) → [SizeOf R] → SizeOf (Rack.PreEnvelGroupRel' R a a_1) |
_private.Batteries.Tactic.Alias.0.Batteries.Tactic.Alias.AliasInfo.name.match_1 | Batteries.Tactic.Alias | (motive : Batteries.Tactic.Alias.AliasInfo → Sort u_1) →
(x : Batteries.Tactic.Alias.AliasInfo) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.plain n)) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.forward n)) →
((n : Lean.Name) → motive (Batteries.Tactic.Alias.AliasInfo.reverse n)) → motive x |
IsLocalization.height_comap | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {A : Type u_2} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[IsLocalization S A] (J : Ideal A), (Ideal.comap (algebraMap R A) J).height = J.height |
Int.instIsCancelMulZero | Mathlib.Algebra.Ring.Int.Defs | IsCancelMulZero ℤ |
_private.Mathlib.Data.Set.Image.0.Set.image_singleton._proof_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {a : α}, f '' {a} = {f a} |
_private.Mathlib.NumberTheory.Padics.ProperSpace.0.PadicInt.totallyBounded_univ._simp_1_3 | Mathlib.NumberTheory.Padics.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) |
_private.Mathlib.Combinatorics.Matroid.Dual.0.Matroid.IsBase.compl_inter_isBasis_of_inter_isBasis._simp_1_2 | Mathlib.Combinatorics.Matroid.Dual | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) |
HomologicalComplex.homologyι | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
(K : HomologicalComplex C c) → (i : ι) → [inst_2 : K.HasHomology i] → K.homology i ⟶ K.opcycles i |
QuaternionAlgebra.instNeg | Mathlib.Algebra.Quaternion | {R : Type u_3} → {c₁ c₂ c₃ : R} → [Neg R] → Neg (QuaternionAlgebra R c₁ c₂ c₃) |
CompleteSublattice.subtype_apply | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (L : Sublattice α) (a : ↥L), L.subtype a = ↑a |
NonarchAddGroupSeminorm.add_bddBelow_range_add | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddCommGroup E] {p q : NonarchAddGroupSeminorm E} {x : E},
BddBelow (Set.range fun y => p y + q (x - y)) |
ProbabilityTheory.Kernel.ext_fun_iff | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β},
κ = η ↔ ∀ (a : α) (f : β → ENNReal), Measurable f → ∫⁻ (b : β), f b ∂κ a = ∫⁻ (b : β), f b ∂η a |
strictConvexOn_rpow | Mathlib.Analysis.Convex.SpecificFunctions.Basic | ∀ {p : ℝ}, 1 < p → StrictConvexOn ℝ (Set.Ici 0) fun x => x ^ p |
BitVec.extractLsb'_eq_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {start : ℕ}, BitVec.extractLsb' start 0 x = 0#0 |
RightCancelMonoid | Mathlib.Algebra.Group.Defs | Type u → Type u |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.normNumPositivity._proof_1 | Mathlib.Tactic.Positivity.Core | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (_a : Q(Semiring «$α»)),
«$zα» =Q «$_a».toNonAssocSemiring.toMulZeroClass.toZero |
CategoryTheory.ShortComplex.SnakeInput.φ₁_L₂_f_assoc | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C) {Z : C} (h : S.L₂.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp S.φ₁ (CategoryTheory.CategoryStruct.comp S.L₂.f h) =
CategoryTheory.CategoryStruct.comp S.φ₂ h |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.getRel.match_1 | Batteries.Tactic.Trans | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((rel x : Lean.Expr) → motive (rel, x)) → motive __discr |
Lean.Meta.LazyDiscrTree.PartialMatch.score | Lean.Meta.LazyDiscrTree | Lean.Meta.LazyDiscrTree.PartialMatch → ℕ |
ContinuousAt.comp₂_of_eq | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : Y × Z → W} {g : X → Y} {h : X → Z} {x : X}
{y : Y × Z},
ContinuousAt f y → ContinuousAt g x → ContinuousAt h x → (g x, h x) = y → ContinuousAt (fun x => f (g x, h x)) x |
_private.Mathlib.Tactic.Positivity.Basic.0.Mathlib.Meta.Positivity.evalIte._proof_1 | Mathlib.Tactic.Positivity.Basic | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_b : Q(Preorder «$α»)), «$_b» =Q «$pα».toPreorder |
ContinuousENorm.toENorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → {inst : TopologicalSpace E} → [self : ContinuousENorm E] → ENorm E |
NNReal.instSemifield._proof_12 | Mathlib.Data.NNReal.Defs | ∀ (n : ℕ) (a : NNReal), CommGroupWithZero.zpow (Int.negSucc n) a = (CommGroupWithZero.zpow (↑n.succ) a)⁻¹ |
Submonoid.instCompleteLattice.eq_1 | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M],
Submonoid.instCompleteLattice =
{ le := fun x1 x2 => x1 ≤ x2, lt := fun x1 x2 => x1 < x2, le_refl := ⋯, le_trans := ⋯, lt_iff_le_not_ge := ⋯,
le_antisymm := ⋯, sup := SemilatticeSup.sup, le_sup_left := ⋯, le_sup_right := ⋯, sup_le := ⋯,
inf := fun x1 x2 => x1 ⊓ x2, inf_le_left := ⋯, inf_le_right := ⋯, le_inf := ⋯,
toSupSet := (completeLatticeOfInf (Submonoid M) ⋯).toSupSet, le_sSup := ⋯, sSup_le := ⋯,
toInfSet := Submonoid.instInfSet, sInf_le := ⋯, le_sInf := ⋯, toTop := Submonoid.instTop, le_top := ⋯,
toBot := Submonoid.instBot, bot_le := ⋯ } |
IO.Error.mkInterrupted | Init.System.IOError | String → UInt32 → String → IO.Error |
TensorProduct.assoc._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R M (TensorProduct R N P)) |
CategoryTheory.monoidalCategoryMop._proof_9 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : Cᴹᵒᵖ}
(f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f.unmop
{ unmop := CategoryTheory.MonoidalCategoryStruct.tensorUnit C }.unmop).mop
(CategoryTheory.MonoidalCategoryStruct.rightUnitor Y.unmop).mop.hom).unmop =
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X.unmop).mop.hom f).unmop |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.arg_mul_coe_angle._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) |
Lean.ReducibilityHints.isAbbrev | Lean.Declaration | Lean.ReducibilityHints → Bool |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.checkNameExists._sparseCasesOn_1 | Lean.Elab.DocString.Builtin | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.compCreatesLimit._proof_1 | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_8}
[inst_1 : CategoryTheory.Category.{u_7, u_8} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{K : CategoryTheory.Functor J C} {E : Type u_6} [ℰ : CategoryTheory.Category.{u_4, u_6} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.CreatesLimit K F]
[CategoryTheory.CreatesLimit (K.comp F) G], CategoryTheory.Limits.ReflectsLimit K (F.comp G) |
AffineSubspace.direction_top | 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]
[S : AddTorsor V P], ⊤.direction = ⊤ |
Filter.disjoint_pure_pure._simp_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {x y : α}, Disjoint (pure x) (pure y) = (x ≠ y) |
CategoryTheory.PreZeroHypercover.refineOneHypercover_p₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (E : CategoryTheory.PreZeroHypercover X)
[inst_1 : E.HasPullbacks]
(F : (i j : E.I₀) → CategoryTheory.PreZeroHypercover (CategoryTheory.Limits.pullback (E.f i) (E.f j))) (i j : E.I₀)
(k : (F i j).I₀),
(E.refineOneHypercover F).p₁ k =
CategoryTheory.CategoryStruct.comp ((F i j).f k) (CategoryTheory.Limits.pullback.fst (E.f i) (E.f j)) |
NumberField.InfinitePlace.instMulActionAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K], RingHomClass Gal(K/k) K K |
CategoryTheory.Discrete.discreteCases | Mathlib.CategoryTheory.Discrete.Basic | Lean.Elab.Tactic.TacticM Unit |
CategoryTheory.TwoSquare | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
CategoryTheory.Functor C₁ C₂ →
CategoryTheory.Functor C₁ C₃ →
CategoryTheory.Functor C₂ C₄ → CategoryTheory.Functor C₃ C₄ → Type (max u₁ v₄) |
Real.rpow_two | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ), x ^ 2 = x ^ 2 |
CategoryTheory.ShortComplex.SnakeInput.exact_C₁_up._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.CategoryStruct.comp S.v₀₁.τ₁ S.v₁₂.τ₁ = 0 |
_private.Std.Data.HashMap.IteratorLemmas.0.Std.HashMap.Raw.keysIter.eq_1 | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} (m : Std.HashMap.Raw α β), m.keysIter = m.inner.keysIter |
mul_lt_mul_of_pos_right | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α] {a b c : α} [MulPosStrictMono α],
b < c → 0 < a → b * a < c * a |
IsLocalFrameOn.mdifferentiableAt_of_coeff | Mathlib.Geometry.Manifold.VectorBundle.LocalFrame | ∀ {𝕜 : 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] {F : Type u_5} [inst_6 : NormedAddCommGroup F]
[inst_7 : NormedSpace 𝕜 F] {V : M → Type u_6} [inst_8 : TopologicalSpace (Bundle.TotalSpace F V)]
[inst_9 : (x : M) → AddCommGroup (V x)] [inst_10 : (x : M) → Module 𝕜 (V x)]
[inst_11 : (x : M) → TopologicalSpace (V x)] [inst_12 : FiberBundle F V] {ι : Type u_7} {s : ι → (x : M) → V x}
{u : Set M} {x : M} {t : (x : M) → V x} [VectorBundle 𝕜 F V] (hs : IsLocalFrameOn I F 1 s u) [FiniteDimensional 𝕜 F],
(∀ (i : ι), MDiffAt ((LinearMap.piApply (hs.coeff i)) t) x) → u ∈ nhds x → MDiffAt (T% t) x |
_private.Batteries.Data.Array.Monadic.0.cond.match_1.eq_1 | Batteries.Data.Array.Monadic | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () |
Units.cfcRpow._proof_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] (a : Aˣ) (x : ℝ), 0 ≤ ↑a → ↑a ^ (-x) * ↑a ^ x = 1 |
CategoryTheory.LaxFunctor.map₂_rightUnitor._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.Lax | Lean.Syntax |
CompactlyGenerated.isoEquivHomeo_symm_apply | Mathlib.Topology.Category.CompactlyGenerated | ∀ {X Y : CompactlyGenerated} (f : ↑X.toTop ≃ₜ ↑Y.toTop),
CompactlyGenerated.isoEquivHomeo.symm f = CompactlyGenerated.isoOfHomeo f |
CategoryTheory.MonoidalCategoryStruct.whiskerRight | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
{X₁ X₂ : C} →
(X₁ ⟶ X₂) →
(Y : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ Y ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj X₂ Y |
ContinuousMap.mk | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
(toFun : X → Y) → autoParam (Continuous toFun) ContinuousMap.continuous_toFun._autoParam → C(X, Y) |
OrderIso.Icc._proof_5 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] (e : α ≃o β) (x y : α) (y_1 : ↑(Set.Icc x y)),
(fun z => ⟨e.symm ↑z, ⋯⟩) ((fun z => ⟨e ↑z, ⋯⟩) y_1) = y_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.