name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
exists_countable_dense_no_bot_top | Mathlib.Topology.Order.DenselyOrdered | ∀ (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[TopologicalSpace.SeparableSpace α] [Nontrivial α],
∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∉ s) ∧ ∀ (x : α), IsTop x → x ∉ s |
MeasureTheory.IntegrableOn.intervalIntegrable | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b : ℝ}
{μ : MeasureTheory.Measure ℝ}, MeasureTheory.IntegrableOn f (Set.uIcc a b) μ → IntervalIntegrable f μ a b |
_private.Mathlib.NumberTheory.Real.GoldenRatio.0.Real.fibRec_charPoly_eq._simp_1_2 | Mathlib.NumberTheory.Real.GoldenRatio | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = a • Polynomial.X ^ n |
SimpleGraph.CompleteBipartiteGraph.chromaticNumber | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u_4} {W : Type u_5} [Nonempty V] [Nonempty W], (completeBipartiteGraph V W).chromaticNumber = 2 |
CategoryTheory.Discrete.sumEquiv._proof_9 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_2} {K : Type u_1} (X : CategoryTheory.Discrete (J ⊕ K)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }).map
((CategoryTheory.NatIso.ofComponents
(fun x =>
match x with
| { as := x } =>
match x with
| Sum.inl x =>
CategoryTheory.Iso.refl
((CategoryTheory.Functor.id (CategoryTheory.Discrete (J ⊕ K))).obj { as := Sum.inl x })
| Sum.inr x =>
CategoryTheory.Iso.refl
((CategoryTheory.Functor.id (CategoryTheory.Discrete (J ⊕ K))).obj { as := Sum.inr x }))
⋯).hom.app
X))
((CategoryTheory.Functor.sumIsoExt
(CategoryTheory.Discrete.natIso fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Sum.inl_ (CategoryTheory.Discrete J) (CategoryTheory.Discrete K)).comp
(((CategoryTheory.Discrete.functor fun t => { as := Sum.inl t }).sum'
(CategoryTheory.Discrete.functor fun t => { as := Sum.inr t })).comp
(CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }))).obj
x))
(CategoryTheory.Discrete.natIso fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Sum.inr_ (CategoryTheory.Discrete J) (CategoryTheory.Discrete K)).comp
(((CategoryTheory.Discrete.functor fun t => { as := Sum.inl t }).sum'
(CategoryTheory.Discrete.functor fun t => { as := Sum.inr t })).comp
(CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }))).obj
x))).hom.app
((CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }).obj
X)) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Discrete.functor fun t =>
match t with
| Sum.inl j => Sum.inl { as := j }
| Sum.inr k => Sum.inr { as := k }).obj
X) |
FirstOrder.Language.LHom.comp_id | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (F : L →ᴸ L'), F.comp (FirstOrder.Language.LHom.id L) = F |
HomologicalComplex.rec | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} →
{motive : HomologicalComplex V c → Sort u_2} →
((X : ι → V) →
(d : (i j : ι) → X i ⟶ X j) →
(shape : ∀ (i j : ι), ¬c.Rel i j → d i j = 0) →
(d_comp_d' :
∀ (i j k : ι), c.Rel i j → c.Rel j k → CategoryTheory.CategoryStruct.comp (d i j) (d j k) = 0) →
motive { X := X, d := d, shape := shape, d_comp_d' := d_comp_d' }) →
(t : HomologicalComplex V c) → motive t |
Polynomial.Monic.irreducible_iff_roots_eq_zero_of_degree_le_three | Mathlib.Algebra.Polynomial.SpecificDegree | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R},
p.Monic → 2 ≤ p.natDegree → p.natDegree ≤ 3 → (Irreducible p ↔ p.roots = 0) |
_private.Mathlib.Combinatorics.SimpleGraph.Operations.0.SimpleGraph.disjoint_edge._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u} {G₁ G₂ : SimpleGraph V}, Disjoint G₁ G₂ = Disjoint G₁.edgeSet G₂.edgeSet |
Filter.Germ.instLeftCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [LeftCancelSemigroup M] → LeftCancelSemigroup (l.Germ M) |
nhds_vadd | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : AddGroup G] [inst_2 : AddAction G α]
[ContinuousConstVAdd G α] (c : G) (x : α), nhds (c +ᵥ x) = c +ᵥ nhds x |
StrongFEPair.symm | Mathlib.NumberTheory.LSeries.AbstractFuncEq | {E : Type u_1} → [inst : NormedAddCommGroup E] → [inst_1 : NormedSpace ℂ E] → StrongFEPair E → StrongFEPair E |
NumberField.InfinitePlace.IsUnramified.eq_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (k : Type u_1) [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
(w : NumberField.InfinitePlace K),
NumberField.InfinitePlace.IsUnramified k w = ((w.comap (algebraMap k K)).mult = w.mult) |
CategoryTheory.ShortComplex.LeftHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι c₁) φ.τ₂ =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Fork.ι c₂) →
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Fork.ι c₂) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι c₁) φ.τ₂ |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.Decl.detectSimpleGround.match_3 | Lean.Compiler.IR.SimpleGroundExpr | (motive : Lean.IR.Decl → Sort u_1) →
(d : Lean.IR.Decl) →
((f : Lean.IR.FunId) →
(params : Array Lean.IR.Param) →
(type : Lean.IR.IRType) →
(body : Lean.IR.FnBody) → (info : Lean.IR.DeclInfo) → motive (Lean.IR.Decl.fdecl f params type body info)) →
((x : Lean.IR.Decl) → motive x) → motive d |
Submodule.tensorSpanEquivSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (R : Type u_3) (A : Type u_2) {M : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [IsScalarTower R A M] (s : Set M),
Submodule.span A ↑(Submodule.span R s) = Submodule.span A s |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeAppStagedCore.analyzeArg | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ℕ →
ReaderT Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context
(StateT Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM)
PUnit.{1} |
Std.DHashMap.Const.get?_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool} {k : α},
Std.DHashMap.Const.get? (Std.DHashMap.filter f m) k =
(Std.DHashMap.Const.get? m k).pfilter fun x_2 h' => f (m.getKey k ⋯) x_2 |
Configuration.ProjectivePlane.mk | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
[toHasPoints : Configuration.HasPoints P L] →
(mkLine : {p₁ p₂ : P} → p₁ ≠ p₂ → L) →
(∀ {p₁ p₂ : P} (h : p₁ ≠ p₂), p₁ ∈ mkLine h ∧ p₂ ∈ mkLine h) →
(∃ p₁ p₂ p₃ l₁ l₂ l₃, p₁ ∉ l₂ ∧ p₁ ∉ l₃ ∧ p₂ ∉ l₁ ∧ p₂ ∈ l₂ ∧ p₂ ∈ l₃ ∧ p₃ ∉ l₁ ∧ p₃ ∈ l₂ ∧ p₃ ∉ l₃) →
Configuration.ProjectivePlane P L |
VonNeumannAlgebra.IsIdempotentElem.mem_iff | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
{e : H →L[ℂ] H},
IsIdempotentElem e →
∀ (S : VonNeumannAlgebra H),
e ∈ S ↔ ∀ y ∈ S.commutant, (↑e).range ∈ Module.End.invtSubmodule ↑y ∧ (↑e).ker ∈ Module.End.invtSubmodule ↑y |
TopCat.ballInclusion._proof_3 | Mathlib.Topology.Category.TopCat.Sphere | ∀ (n : ℕ) (t : Set (ULift.{u_1, 0} ↑(Metric.closedBall 0 1))) (s : Set ↑(Metric.closedBall 0 1))
(r : Set (EuclideanSpace ℝ (Fin n))),
IsOpen r →
Subtype.val ⁻¹' r = s →
ULift.down ⁻¹' s = t →
IsOpen
((fun x =>
match x with
| { down := ⟨p, hp⟩ } => { down := ⟨p, ⋯⟩ }) ⁻¹'
t) |
PowerSeries.heval._proof_3 | Mathlib.RingTheory.HahnSeries.HEval | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] (x : HahnSeries Γ R), (HahnSeries.SummableFamily.powerSeriesFamily x 1).hsum = 1 |
Equiv.sumAssoc | Mathlib.Logic.Equiv.Sum | (α : Type u_9) → (β : Type u_10) → (γ : Type u_11) → (α ⊕ β) ⊕ γ ≃ α ⊕ β ⊕ γ |
HasFTaylorSeriesUpTo.zero_eq | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{f : E → F} {p : E → FormalMultilinearSeries 𝕜 E F}, HasFTaylorSeriesUpTo n f p → ∀ (x : E), (p x 0).curry0 = f x |
_private.Init.Data.Fin.Lemmas.0.Fin.instLawfulOrderLT._simp_2 | Init.Data.Fin.Lemmas | ∀ {a b : Prop} [Decidable a], (a → b) = (¬a ∨ b) |
Vector.set_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {xs : Vector α n} {x y : α} {h : i < n + 1},
(xs.push x).set i y h = if x_1 : i < n then (xs.set i y x_1).push x else xs.push y |
Std.TreeMap.minKey?_alter_eq_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{f : Option β → Option β}, (t.alter k f).minKey? = some k ↔ (f t[k]?).isSome = true ∧ ∀ k' ∈ t, (cmp k k').isLE = true |
AnalyticOnNhd.congr' | Mathlib.Analysis.Analytic.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] {f g : E → F} {s : Set E},
AnalyticOnNhd 𝕜 f s → f =ᶠ[nhdsSet s] g → AnalyticOnNhd 𝕜 g s |
CategoryTheory.fieldEndOfFiniteDimensional._proof_4 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] (X : C) [inst_3 : CategoryTheory.Simple X] (n : ℕ)
(a : CategoryTheory.End X), DivisionRing.zpow (↑n.succ) a = DivisionRing.zpow (↑n) a * a |
_private.Mathlib.CategoryTheory.Monoidal.Free.Coherence.0.CategoryTheory.FreeMonoidalCategory.normalizeIsoApp'.match_1.splitter | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u_1) →
(motive :
CategoryTheory.FreeMonoidalCategory C → CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_2) →
(x : CategoryTheory.FreeMonoidalCategory C) →
(x_1 : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
((a : C) →
(x : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
motive (CategoryTheory.FreeMonoidalCategory.of a) x) →
((x : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
motive CategoryTheory.FreeMonoidalCategory.unit x) →
((X Y : CategoryTheory.FreeMonoidalCategory C) →
(n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) → motive (X.tensor Y) n) →
motive x x_1 |
Std.DTreeMap.Internal.Impl.balancedAtRoot_one_two._simp_1 | Std.Data.DTreeMap.Internal.Balanced | Std.DTreeMap.Internal.Impl.BalancedAtRoot 1 2 = True |
dist_add_dist_of_mem_segment | Mathlib.Analysis.Normed.Affine.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {x y z : E},
y ∈ segment ℝ x z → dist x y + dist y z = dist x z |
_private.Lean.Widget.InteractiveCode.0.Lean.Widget.instFromJsonDiffTag.fromJson.match_3 | Lean.Widget.InteractiveCode | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x |
WithTop.zero_eq_coe | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {a : α}, 0 = ↑a ↔ a = 0 |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {w : ℕ}
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign aig cache →
∀ (expr : Std.Tactic.BVDecide.BVExpr w),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign
(↑(Std.Tactic.BVDecide.BVExpr.bitblast.goCache aig expr cache).result).aig
(Std.Tactic.BVDecide.BVExpr.bitblast.goCache aig expr cache).cache |
divp_mul_cancel | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a : α) (u : αˣ), a /ₚ u * ↑u = a |
Lean.Meta.Grind.SplitStatus.resolved | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitStatus |
map_mem_nonunits_iff._simp_1 | Mathlib.RingTheory.Ideal.Nonunits | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] [inst_2 : FunLike F α β]
[MonoidHomClass F α β] (f : F) [IsLocalHom f] (a : α), (f a ∈ nonunits β) = (a ∈ nonunits α) |
EarlyReturnT | Init.Control.Do | Type u_1 → (Type u_1 → Type u_2) → Type u_1 → Type u_2 |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_append._proof_5 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → ¬n + (m - 1) = n + m - 1 → False |
Set.eqOn_union._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {f₁ f₂ : α → β},
Set.EqOn f₁ f₂ (s₁ ∪ s₂) = (Set.EqOn f₁ f₂ s₁ ∧ Set.EqOn f₁ f₂ s₂) |
_private.Mathlib.Order.ScottContinuity.0.ScottContinuousOn.prodMk._simp_1_2 | Mathlib.Order.ScottContinuity | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
ComplexShape.QFactorsThroughHomotopy.mk._flat_ctor | Mathlib.Algebra.Homology.Localization | ∀ {ι : Type u_3} {c : ComplexShape ι} {C : Type u_4} [inst : CategoryTheory.Category.{v_2, u_4} C]
[inst_1 : CategoryTheory.Preadditive C] [inst_2 : CategoryTheory.CategoryWithHomology C],
(∀ {K L : HomologicalComplex C c} {f g : K ⟶ L} (h : Homotopy f g),
CategoryTheory.AreEqualizedByLocalization (HomologicalComplex.quasiIso C c) f g) →
c.QFactorsThroughHomotopy C |
QuadraticForm.toDualProd | Mathlib.LinearAlgebra.QuadraticForm.Dual | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(Q : QuadraticForm R M) → [Invertible 2] → QuadraticMap.prod Q (-Q) →qᵢ QuadraticForm.dualProd R M |
CategoryTheory.ChosenPullbacksAlong.pullbackMap_snd._auto_3 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax |
ContMDiffAddMonoidMorphism._sizeOf_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{H : Type u_2} →
{inst_1 : TopologicalSpace H} →
{E : Type u_3} →
{inst_2 : NormedAddCommGroup E} →
{inst_3 : NormedSpace 𝕜 E} →
{H' : Type u_5} →
{inst_4 : TopologicalSpace H'} →
{E' : Type u_6} →
{inst_5 : NormedAddCommGroup E'} →
{inst_6 : NormedSpace 𝕜 E'} →
{I : ModelWithCorners 𝕜 E H} →
{I' : ModelWithCorners 𝕜 E' H'} →
{n : WithTop ℕ∞} →
{G : Type u_8} →
{inst_7 : TopologicalSpace G} →
{inst_8 : ChartedSpace H G} →
{inst_9 : AddMonoid G} →
{G' : Type u_9} →
{inst_10 : TopologicalSpace G'} →
{inst_11 : ChartedSpace H' G'} →
{inst_12 : AddMonoid G'} →
[SizeOf 𝕜] →
[SizeOf H] →
[SizeOf E] →
[SizeOf H'] →
[SizeOf E'] →
[SizeOf G] →
[SizeOf G'] → ContMDiffAddMonoidMorphism I I' n G G' → ℕ |
ProbabilityTheory.condIndepFun_iff_map_prod_eq_prod_map_map | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{hm' : m' ≤ mΩ} {μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} [MeasurableSpace.CountableOrCountablyGenerated Ω (β × β')],
Measurable f →
Measurable g →
(ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
⇑((ProbabilityTheory.condExpKernel μ m').map fun ω => (f ω, g ω)) =ᵐ[μ.trim hm']
⇑(((ProbabilityTheory.condExpKernel μ m').map f).prod ((ProbabilityTheory.condExpKernel μ m').map g))) |
CategoryTheory.MorphismProperty.relative_map_iff | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {P : CategoryTheory.MorphismProperty C} [F.Faithful] [F.Full]
[CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingCospan F]
[CategoryTheory.Limits.HasPullbacks C] [P.IsStableUnderBaseChange] {X Y : C} {f : X ⟶ Y},
CategoryTheory.MorphismProperty.relative F P (F.map f) ↔ P f |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.classInductive.formatter_137 | Lean.Parser.Command | IO Unit |
MeasureTheory.Lp.dist_eq_norm | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)), dist f g = ‖-f + g‖ |
MeasureTheory.hasFiniteIntegral_count_iff_enorm | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} [inst : ENorm ε] [MeasurableSingletonClass α] {f : α → ε},
MeasureTheory.HasFiniteIntegral f MeasureTheory.Measure.count ↔ ∑' (x : α), ‖f x‖ₑ < ⊤ |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.processLevel.match_1.eq_1 | Lean.Meta.Sym.Pattern | ∀ (motive : Option ℕ → Sort u_1) (uidx : ℕ) (h_1 : (uidx : ℕ) → motive (some uidx)) (h_2 : (x : Option ℕ) → motive x),
(match some uidx with
| some uidx => h_1 uidx
| x => h_2 x) =
h_1 uidx |
DirectLimit.instSMulZeroClassOfMulActionHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_1} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → Zero (G i)] [inst_6 : (i : ι) → SMulZeroClass R (G i)] (r : R),
⟦⟨Classical.arbitrary ι, r • (fun x => 0) (Classical.arbitrary ι)⟩⟧ = 0 |
CategoryTheory.Pretriangulated.Triangle.rotate_obj₃ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
T.rotate.obj₃ = (CategoryTheory.shiftFunctor C 1).obj T.obj₁ |
biInf_ge_eq_of_monotone | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ (b : β), ⨅ b', ⨅ (_ : b' ≥ b), f b' = f b |
BoxIntegral.unitPartition.prepartition_isPartition | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] {B : BoxIntegral.Box ι},
BoxIntegral.hasIntegralVertices B → (BoxIntegral.unitPartition.prepartition n B).IsPartition |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.eq_of_pairwise_lt_of_mem_iff_mem._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) |
Lean.Parser.Tactic.MCasesPat.clear | Std.Tactic.Do.Syntax | Lean.Parser.Tactic.MCasesPat |
Ordinal.card_lt_ofNat | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} {n : ℕ} [inst : n.AtLeastTwo], o.card < OfNat.ofNat n ↔ o < OfNat.ofNat n |
FirstOrder.Language.BoundedFormula.realize_inf._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ ⊓ ψ).Realize v xs = (φ.Realize v xs ∧ ψ.Realize v xs) |
Lean.Lsp.Ipc.ModuleHierarchy.mk.inj | Lean.Data.Lsp.Ipc | ∀ {item : Lean.Lsp.LeanImport} {children : Array Lean.Lsp.Ipc.ModuleHierarchy} {item_1 : Lean.Lsp.LeanImport}
{children_1 : Array Lean.Lsp.Ipc.ModuleHierarchy},
{ item := item, children := children } = { item := item_1, children := children_1 } →
item = item_1 ∧ children = children_1 |
Std.Iter.step_take | Init.Data.Iterators.Lemmas.Combinators.Take | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} {it : Std.Iter β},
(Std.Iter.take n it).step =
match n with
| 0 => Std.PlausibleIterStep.done ⋯
| k.succ =>
match it.step with
| ⟨Std.IterStep.yield it' out, h⟩ => Std.PlausibleIterStep.yield (Std.Iter.take k it') out ⋯
| ⟨Std.IterStep.skip it', h⟩ => Std.PlausibleIterStep.skip (Std.Iter.take (k + 1) it') ⋯
| ⟨Std.IterStep.done, h⟩ => Std.PlausibleIterStep.done ⋯ |
CategoryTheory.Precoverage.instCompleteLattice._proof_4 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (x x_1 : CategoryTheory.Precoverage C),
(x ⊓ x_1).coverings = (x ⊓ x_1).coverings |
AntisymmRel.antisymmRel_congr_right | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
AntisymmRel (fun x1 x2 => x1 ≤ x2) b c →
(AntisymmRel (fun x1 x2 => x1 ≤ x2) a b ↔ AntisymmRel (fun x1 x2 => x1 ≤ x2) a c) |
_private.Aesop.Script.StructureDynamic.0.Aesop.Script.structureDynamicCore.go | Aesop.Script.StructureDynamic | Lean.MVarId →
Lean.Meta.SavedState → Array Lean.MVarId → Aesop.Script.DynStructureM (Option Aesop.Script.DynStructureResult) |
_private.Lean.Elab.Deriving.FromToJson.0.Lean.Elab.Deriving.FromToJson.initFn._@.Lean.Elab.Deriving.FromToJson.2304768170._hygCtx._hyg.2 | Lean.Elab.Deriving.FromToJson | IO Unit |
mem_segment_iff_sameRay | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E}, x ∈ segment 𝕜 y z ↔ SameRay 𝕜 (x - y) (z - x) |
MeasureTheory.Integrable.sub' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f g : α → β},
MeasureTheory.Integrable f μ → MeasureTheory.Integrable g μ → MeasureTheory.Integrable (fun a => f a - g a) μ |
Ideal.neg_mem_iff | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Ring α] (I : Ideal α) {a : α}, -a ∈ I ↔ a ∈ I |
AlgebraicGeometry.affineLocally_iff_forall_isAffineOpen | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ (P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) {X Y : AlgebraicGeometry.Scheme}
(f : X ⟶ Y),
AlgebraicGeometry.affineLocally (fun {R S} [CommRing R] [CommRing S] => P) f ↔
∀ {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ {V : X.Opens},
AlgebraicGeometry.IsAffineOpen V →
∀ (e : V ≤ (TopologicalSpace.Opens.map f.base).obj U),
P (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V e)) |
Nat.length_repr_pos | Init.Data.Nat.ToString | ∀ {n : ℕ}, 0 < n.repr.length |
PseudoEpimorphism.copy._proof_2 | Mathlib.Topology.Order.Hom.Esakia | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (f : PseudoEpimorphism α β) (f' : α → β)
(h : f' = ⇑f) ⦃a : α⦄ ⦃b : β⦄, (f.copy f' h).toFun a ≤ b → ∃ c, a ≤ c ∧ (f.copy f' h).toFun c = b |
CategoryTheory.SpectralSequence.pageFunctor._proof_2 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_2}
(c : ℤ → ComplexShape κ) (r₀ r : ℤ) (hr : r₀ ≤ r) {X Y Z : CategoryTheory.SpectralSequence C c r₀} (f : X ⟶ Y)
(g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).hom r ⋯ = CategoryTheory.CategoryStruct.comp (f.hom r ⋯) (g.hom r ⋯) |
Lean.Elab.Term.collectUnassignedMVars | Lean.Elab.Term.TermElabM | Lean.Expr →
optParam (Array Lean.Expr) #[] →
(optParam (Lean.MVarId → Bool) fun x => false) → Lean.Elab.TermElabM (Array Lean.Expr) |
neg_concaveOn_iff._simp_1 | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f : E → β}, ConcaveOn 𝕜 s (-f) = ConvexOn 𝕜 s f |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.maxView.match_1.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β)
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3)
(size : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hr : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced)
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size)
(h_1 :
(hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size Std.DTreeMap.Internal.Impl.leaf.size) →
motive Std.DTreeMap.Internal.Impl.leaf hr hlr)
(h_2 :
(size : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hr : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hr hlr),
(match Std.DTreeMap.Internal.Impl.inner size k' v' l' r', hr, hlr with
| Std.DTreeMap.Internal.Impl.leaf, hr, hlr => h_1 hr hlr
| Std.DTreeMap.Internal.Impl.inner size k' v' l' r', hr, hlr => h_2 size k' v' l' r' hr hlr) =
h_2 size k' v' l' r' hr hlr |
ContMDiffMap.restrictMonoidHom | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{E' : Type u_3} →
[inst_3 : NormedAddCommGroup E'] →
[inst_4 : NormedSpace 𝕜 E'] →
{H : Type u_4} →
[inst_5 : TopologicalSpace H] →
(I : ModelWithCorners 𝕜 E H) →
{H' : Type u_5} →
[inst_6 : TopologicalSpace H'] →
(I' : ModelWithCorners 𝕜 E' H') →
{N : Type u_6} →
[inst_7 : TopologicalSpace N] →
[inst_8 : ChartedSpace H N] →
{n : WithTop ℕ∞} →
(G : Type u_10) →
[inst_9 : Monoid G] →
[inst_10 : TopologicalSpace G] →
[inst_11 : ChartedSpace H' G] →
[inst_12 : ContMDiffMul I' n G] →
{U V : TopologicalSpace.Opens N} →
U ≤ V → ContMDiffMap I I' (↥V) G n →* ContMDiffMap I I' (↥U) G n |
CategoryTheory.Limits.Cones.postcomposeId_inv_app_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (X : CategoryTheory.Limits.Cone F),
(CategoryTheory.Limits.Cones.postcomposeId.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt |
Lean.Elab.Tactic.evalReplace._regBuiltin.Lean.Elab.Tactic.evalReplace.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_theta_div_log_sq_isBigO._simp_1_4 | Mathlib.NumberTheory.Chebyshev | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
CategoryTheory.ConcreteCategory.epi_of_surjective | Mathlib.CategoryTheory.ConcreteCategory.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y : C}
(f : X ⟶ Y), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f) → CategoryTheory.Epi f |
FreeGroup.instInv._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} ⦃a b : List (α × Bool)⦄,
FreeGroup.Red.Step a b → FreeGroup.Red.Step (FreeGroup.invRev a) (FreeGroup.invRev b) |
FiniteField.pow_card | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : GroupWithZero K] [inst_1 : Fintype K] (a : K), a ^ Fintype.card K = a |
Path.instHSpace | Mathlib.Topology.Homotopy.HSpaces | {X : Type u} → [inst : TopologicalSpace X] → (x : X) → HSpace (Path x x) |
Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State → ℕ |
ContDiffAt.abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {n : ℕ∞} {f : E → ℝ} {x : E},
ContDiffAt ℝ (↑n) f x → f x ≠ 0 → ContDiffAt ℝ (↑n) (fun x => |f x|) x |
_private.Batteries.Data.List.Lemmas.0.List.mem_idxsOf_iff_getElem_pos._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (hi : i < xs.length),
i ∈ List.idxsOf x xs ↔ (xs[i] == x) = true |
_private.Mathlib.Topology.Algebra.Group.SubmonoidClosure.0.mapClusterPt_inv_atTop_pow._simp_1_1 | Mathlib.Topology.Algebra.Group.SubmonoidClosure | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [CompactSpace G] [inst_3 : IsTopologicalGroup G]
{x y : G}, (MapClusterPt x Filter.atTop fun x => y ^ x) = (x ∈ (Subgroup.zpowers y).topologicalClosure) |
Multiset.filter_sub | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} [inst : DecidableEq α] (p : α → Prop) [inst_1 : DecidablePred p] (s t : Multiset α),
Multiset.filter p (s - t) = Multiset.filter p s - Multiset.filter p t |
Encodable.decode_unit_succ | Mathlib.Logic.Encodable.Basic | ∀ (n : ℕ), Encodable.decode n.succ = none |
instMonadFinallyEST | Init.System.ST | {ε σ : Type} → MonadFinally (EST ε σ) |
AddEquiv.piAddUnits | Mathlib.Algebra.Group.Pi.Units | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → AddMonoid (M i)] → AddUnits ((i : ι) → M i) ≃+ ((i : ι) → AddUnits (M i)) |
SSet.PtSimplex.MulStruct.δ_map_of_lt | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk 0))} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i),
∀ j < i.castSucc.castSucc, CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) self.map = SSet.const x |
_private.Mathlib.Tactic.Linarith.Parsing.0.Mathlib.Tactic.Linarith.linearFormOfExpr.match_9 | Mathlib.Tactic.Linarith.Parsing | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → (Unit → motive (some 0)) → ((n : ℕ) → motive (some n.succ)) → (Unit → motive none) → motive x |
Prod.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (a : R × S),
a * 0 = 0 |
Real.iteratedDeriv_odd_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (n : ℕ), iteratedDeriv (2 * n + 1) Real.sinh = Real.cosh |
nonemptyFinLinOrdDualCompForgetToFinPartOrd | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd.dual.comp (CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd) ≅
(CategoryTheory.forget₂ NonemptyFinLinOrd FinPartOrd).comp FinPartOrd.dual |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_fold_fn_preserves_induction_motive._proof_1_13 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} {c_arr : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))} (idx : Fin c_arr.size),
↑idx < c_arr.size |
Rat.lt_toNNRat_iff_coe_lt | Mathlib.Data.NNRat.Defs | ∀ {p : ℚ} {q : ℚ≥0}, q < p.toNNRat ↔ ↑q < p |
summable_eisSummand | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {k : ℕ}, 3 ≤ k → ∀ (z : UpperHalfPlane), Summable fun x => EisensteinSeries.eisSummand (↑k) x z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.