name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Topology.EMetricSpace.Diam.0.Metric.ediam_pos_iff'._simp_1_1 | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : EMetricSpace X], (0 < Metric.ediam s) = s.Nontrivial |
measurableSet_preimage_up._simp_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set (ULift.{u_6, u_1} α)},
MeasurableSet (ULift.up ⁻¹' s) = MeasurableSet s |
LinearPMap.comp | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} →
[inst_3 : AddCommGroup F] →
[inst_4 : Module R F] →
{G : Type u_4} →
[inst_5 : AddCommGroup G] →
[inst_6 : Module R G] →
(g : F →ₗ.[R] G) → (f : E →ₗ.[R] F) → (∀ (x : ↥f.domain), ↑f x ∈ g.domain) → E →ₗ.[R] G |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Ideal.isPrime_map_C_iff_isPrime._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) |
AddMonoidHom.coe_snd | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N], ⇑(AddMonoidHom.snd M N) = Prod.snd |
KaehlerDifferential.mulActionBaseChange._proof_1 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A], SMulCommClass R R A |
MvQPF.wSetoid | Mathlib.Data.QPF.Multivariate.Constructions.Fix | {n : ℕ} → {F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → (α : TypeVec.{u} n) → Setoid ((MvQPF.P F).W α) |
Lean.Elab.Term.LetIdDeclView._sizeOf_inst | Lean.Elab.Binders | SizeOf Lean.Elab.Term.LetIdDeclView |
ProbabilityTheory.condCDF_le_one | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (x : ℝ),
↑(ProbabilityTheory.condCDF ρ a) x ≤ 1 |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.reverse_balLeft._proof_1_18 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} (l : Batteries.RBNode α) (v : α) (r r' l' : Batteries.RBNode α),
r' = r.reverse →
l' = l.reverse →
(Batteries.RBNode.node Batteries.RBColor.red l v r).reverse = Batteries.RBNode.node Batteries.RBColor.red r' v l' |
CategoryTheory.Monad.beckAlgebraCofork_pt | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckAlgebraCofork X).pt = X |
LinearMap.piApply._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R], SMulCommClass R R (M → R) |
Lean.NameMapExtension | Batteries.Lean.NameMapAttribute | Type → Type |
eqOn_of_cfcₙ_eq_cfcₙ._auto_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Batteries.RBNode.Balanced.setBlack | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {t : Batteries.RBNode α} {c : Batteries.RBColor} {n : ℕ},
t.Balanced c n → ∃ n', t.setBlack.Balanced Batteries.RBColor.black n' |
AlgebraicGeometry.spread_out_unique_of_isGermInjective | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {x : ↥X} [X.IsGermInjectiveAt x] (f g : X ⟶ Y) (e : f x = g x),
AlgebraicGeometry.Scheme.Hom.stalkMap f x =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯) (AlgebraicGeometry.Scheme.Hom.stalkMap g x) →
∃ U, x ∈ U ∧ CategoryTheory.CategoryStruct.comp U.ι f = CategoryTheory.CategoryStruct.comp U.ι g |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
_private.Aesop.Rule.0.Aesop.instBEqRegularRule.beq._sparseCasesOn_2 | Aesop.Rule | {motive : Aesop.RegularRule → Sort u} →
(t : Aesop.RegularRule) →
((r : Aesop.UnsafeRule) → motive (Aesop.RegularRule.unsafe r)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Analysis.Asymptotics.Completion.0.«term_̂» | Mathlib.Analysis.Asymptotics.Completion | Lean.TrailingParserDescr |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_6 | Mathlib.Topology.Sequences | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
Std.IterM.findM?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
[LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{f : β → m (ULift.{w, 0} Bool)},
it.findM? f = do
let __do_lift ← it.step
match ↑__do_lift.inflate with
| Std.IterStep.yield it' out => do
let __do_lift ← f out
if __do_lift.down = true then pure (some out) else it'.findM? f
| Std.IterStep.skip it' => it'.findM? f
| Std.IterStep.done => pure none |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toList_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) |
Std.Tactic.BVDecide.LRAT.Internal.Entails.noConfusionType | Std.Tactic.BVDecide.LRAT.Internal.Entails | Sort u_1 →
{α : Type u} →
{β : Type v} →
Std.Tactic.BVDecide.LRAT.Internal.Entails α β →
{α' : Type u} → {β' : Type v} → Std.Tactic.BVDecide.LRAT.Internal.Entails α' β' → Sort u_1 |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_getElem._proof_2 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pos.offset.byteIdx + pat.copy.toByteArray.size ≤ s.copy.toByteArray.size →
∀ j < pat.copy.toByteArray.size, pos.offset.byteIdx + j < s.copy.toByteArray.size |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
MulOpposite.instCoalgebra._proof_8 | Mathlib.RingTheory.Coalgebra.MulOpposite | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A],
SMulCommClass R R (TensorProduct R Aᵐᵒᵖ R) |
CategoryTheory.FreeBicategory.Hom.brecOn.eq | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} {a a_1 : B}
(t : CategoryTheory.FreeBicategory.Hom a a_1)
(F_1 :
(a a_2 : B) →
(t : CategoryTheory.FreeBicategory.Hom a a_2) → CategoryTheory.FreeBicategory.Hom.below t → motive a a_2 t),
CategoryTheory.FreeBicategory.Hom.brecOn t F_1 = F_1 a a_1 t (CategoryTheory.FreeBicategory.Hom.brecOn.go t F_1).2 |
ContinuousMap.instCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : CommCStarAlgebra A],
CompleteSpace C(α, A) |
CategoryTheory.Pretriangulated.productTriangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₃]
[inst_5 : CategoryTheory.Limits.HasProduct fun j => (CategoryTheory.shiftFunctor C 1).obj (T j).obj₁],
(CategoryTheory.Pretriangulated.productTriangle T).obj₁ = ∏ᶜ fun j => (T j).obj₁ |
_private.Init.Prelude.0.ne_false_of_eq_true.match_1_1 | Init.Prelude | ∀ (motive : (x : Bool) → x = true → Prop) (x : Bool) (x_1 : x = true),
(∀ (x : true = true), motive true x) → (∀ (h : false = true), motive false h) → motive x x_1 |
Quiver.IsStronglyConnected.nonempty_path | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_2) [inst : Quiver V], Quiver.IsStronglyConnected V → ∀ (i j : V), Nonempty (Quiver.Path i j) |
_private.Mathlib.Combinatorics.Schnirelmann.0.schnirelmannDensity_setOf_mod_eq_one._simp_1_4 | Mathlib.Combinatorics.Schnirelmann | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) |
AddSubmonoid.gciMapComap._proof_3 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), ∀ x ∈ AddSubmonoid.comap f (AddSubmonoid.map f S), x ∈ S |
instMetricSpaceOrderDual | Mathlib.Topology.MetricSpace.Defs | {X : Type u_1} → [MetricSpace X] → MetricSpace Xᵒᵈ |
groupHomology.chainsMap._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u_1} [inst : CommRing k], RingHomCompTriple (RingHom.id k) (RingHom.id k) (RingHom.id k) |
eq_nnratCast | Mathlib.Data.Rat.Cast.Defs | ∀ {F : Type u_1} {α : Type u_3} [inst : DivisionSemiring α] [inst_1 : FunLike F ℚ≥0 α] [RingHomClass F ℚ≥0 α] (f : F)
(q : ℚ≥0), f q = ↑q |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul✝ = 1 |
Lean.Elab.Term.LetConfig.rec | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generalize := generalize, eq? := eq? }) →
(t : Lean.Elab.Term.LetConfig) → motive t |
YoungDiagram.cells_subset_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.cells ⊆ ν.cells ↔ μ ≤ ν |
CauSeq.Completion.ofRat_neg | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : β),
CauSeq.Completion.ofRat (-x) = -CauSeq.Completion.ofRat x |
Array.eraseP_map | Init.Data.Array.Erase | ∀ {β : Type u_1} {α : Type u_2} {p : α → Bool} {f : β → α} {xs : Array β},
(Array.map f xs).eraseP p = Array.map f (xs.eraseP (p ∘ f)) |
PerfectClosure.instCommRing._proof_18 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(a : PerfectClosure K p), SubNegMonoid.zsmul 0 a = 0 |
AlgebraicGeometry.IsSeparated.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsSeparated (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsSeparated f |
Topology.IsUpper.isTopologicalSpace_basis | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] [t : TopologicalSpace α] [Topology.IsUpper α] (U : Set α),
IsOpen U ↔ U = Set.univ ∨ ∃ a, (Set.Iic a)ᶜ = U |
_private.Mathlib.Topology.Order.LeftRightNhds.0.eventually_mabs_div_lt._simp_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u} (s : Set α), (s ∈ Filter.principal s) = True |
Lean.Lsp.DidSaveTextDocumentParams.mk.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{text? : Option String} →
{textDocument' : Lean.Lsp.TextDocumentIdentifier} →
{text?' : Option String} →
{ textDocument := textDocument, text? := text? } = { textDocument := textDocument', text? := text?' } →
(textDocument = textDocument' → text? = text?' → P) → P |
AddEquivClass.map_add | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_9} {A : outParam (Type u_10)} {B : outParam (Type u_11)} {inst : Add A} {inst_1 : Add B}
{inst_2 : EquivLike F A B} [self : AddEquivClass F A B] (f : F) (a b : A), f (a + b) = f a + f b |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.extractClosed._proof_1 | Lean.Compiler.LCNF.ExtractClosed | Lean.Compiler.LCNF.Phase.mono ≥ Lean.Compiler.LCNF.Phase.mono |
Set.infs_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] (s t u : Set α), s ⊼ t ⊼ u = s ⊼ (t ⊼ u) |
Filter.cocardinal_aleph0_eq_cofinite | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u}, Filter.cocardinal α Cardinal.isRegular_aleph0 = Filter.cofinite |
Sbtw.left_ne_right | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y z : P}, Sbtw R x y z → x ≠ z |
CategoryTheory.Under.mapCongr._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X Y : T} (f g : X ⟶ Y),
f = g → ∀ (A : CategoryTheory.Under Y), (CategoryTheory.Under.map f).obj A = (CategoryTheory.Under.map g).obj A |
PresheafOfModules.instModuleCarrierStalkCommRingCatCarrierAbPresheafOpensCarrier._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {X : TopCat} {R : TopCat.Presheaf CommRingCat X}
(M : PresheafOfModules (CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat))) (x : ↑X)
{i j : (TopologicalSpace.OpenNhds x)ᵒᵖ} (f : i ⟶ j)
(r :
↑(((TopologicalSpace.OpenNhds.inclusion x).op.comp
(CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat))).obj
i))
(m : ↑(((TopologicalSpace.OpenNhds.inclusion x).op.comp M.presheaf).obj i)),
(CategoryTheory.ConcreteCategory.hom (M.map ((TopologicalSpace.OpenNhds.inclusion x).op.map f))) (r • m) =
(CategoryTheory.ConcreteCategory.hom
((CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat)).map
((TopologicalSpace.OpenNhds.inclusion x).op.map f)))
r •
(CategoryTheory.ConcreteCategory.hom (M.map ((TopologicalSpace.OpenNhds.inclusion x).op.map f))) m |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.Isometry.hausdorffMeasure_image._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (m : ENNReal → ENNReal),
⇑(MeasureTheory.Measure.mkMetric m) = ⇑(MeasureTheory.OuterMeasure.mkMetric m) |
instLawfulMonadTacticM_batteries | Batteries.Lean.LawfulMonad | LawfulMonad Lean.Elab.Tactic.TacticM |
TopologicalSpace.Opens.map_comp_obj' | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Set ↑Z) (p : IsOpen U),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).obj { carrier := U, is_open' := p } =
(TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p }) |
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft_base | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] [inst_4 : CategoryTheory.Category.{v₅, u₅} B']
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] {F' : CategoryTheory.Functor A' B'} {G' : CategoryTheory.Functor C' B'}
[inst_6 : CategoryTheory.Category.{v₇, u₇} A''] [inst_7 : CategoryTheory.Category.{v₈, u₈} B'']
[inst_8 : CategoryTheory.Category.{v₉, u₉} C''] {F'' : CategoryTheory.Functor A'' B''}
{G'' : CategoryTheory.Functor C'' B''} (φ : CategoryTheory.Limits.CatCospanTransform F G F' G')
{ψ ψ' : CategoryTheory.Limits.CatCospanTransform F' G' F'' G''} (α : ψ ⟶ ψ'),
(CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft φ α).base = φ.base.whiskerLeft α.base |
BitVec.extractLsb'_append_eq_of_le | Init.Data.BitVec.Lemmas | ∀ {v w : ℕ} {xhi : BitVec v} {xlo : BitVec w} {start len : ℕ},
w ≤ start → BitVec.extractLsb' start len (xhi ++ xlo) = BitVec.extractLsb' (start - w) len xhi |
CategoryTheory.CostructuredArrow.isSeparating_proj_preimage | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(S : CategoryTheory.Functor C D) (T : D) {P : CategoryTheory.ObjectProperty C},
P.IsSeparating → (P.inverseImage (CategoryTheory.CostructuredArrow.proj S T)).IsSeparating |
UInt16.toUSize_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a <<< b).toUSize = a.toUSize <<< (b % 16).toUSize % 65536 |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_2 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (s ≤ᵐ[μ] t) = (μ (s \ t) = 0) |
Function.Even | Mathlib.Algebra.Group.EvenFunction | {α : Type u_1} → {β : Type u_2} → [Neg α] → (α → β) → Prop |
Mathlib.Meta.NormNum.IsNNRat.to_isRat | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] {a : α} {n d : ℕ},
Mathlib.Meta.NormNum.IsNNRat a n d → Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) d |
Lean.Lsp.VersionedTextDocumentIdentifier.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.VersionedTextDocumentIdentifier → Sort u} →
(t : Lean.Lsp.VersionedTextDocumentIdentifier) →
((uri : Lean.Lsp.DocumentUri) → (version? : Option ℕ) → motive { uri := uri, version? := version? }) → motive t |
Nat.stirlingSecond._sunfold | Mathlib.Combinatorics.Enumerative.Stirling | ℕ → ℕ → ℕ |
smoothPresheafCommGroup._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H) (M : Type u_1) [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace HM M] (A : Type u_1)
[inst_9 : TopologicalSpace A] [inst_10 : ChartedSpace H A] [inst_11 : CommGroup A] [inst_12 : LieGroup I (↑⊤) A]
(x : (TopologicalSpace.Opens ↑{ carrier := M, str := inst_7 })ᵒᵖ),
CommGrpCat.ofHom (ContMDiffMap.restrictMonoidHom IM I A ⋯) =
CommGrpCat.ofHom (ContMDiffMap.restrictMonoidHom IM I A ⋯) |
AffineIsometryEquiv.toAffineIsometry | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
{P : Type u_10} →
{P₂ : Type u_11} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : NormedAddTorsor V P] →
[inst_5 : SeminormedAddCommGroup V₂] →
[inst_6 : NormedSpace 𝕜 V₂] →
[inst_7 : PseudoMetricSpace P₂] → [inst_8 : NormedAddTorsor V₂ P₂] → (P ≃ᵃⁱ[𝕜] P₂) → P →ᵃⁱ[𝕜] P₂ |
Lean.Elab.Tactic.withCaseRef | Lean.Elab.Tactic.Basic | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.MonadRef m] → Lean.Syntax → Lean.Syntax → m α → m α |
CStarMatrix.mapₗ | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
[inst_2 : AddCommMonoid A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R A] →
[inst_5 : Module S B] → (A →ₛₗ[σ] B) → CStarMatrix m n A →ₛₗ[σ] CStarMatrix m n B |
HasLineDerivWithinAt.mono | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
{s t : Set E} {x v : E}, HasLineDerivWithinAt 𝕜 f f' s x v → t ⊆ s → HasLineDerivWithinAt 𝕜 f f' t x v |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.NotificationOverview.mk.sizeOf_spec | Lean.Server.ProtocolOverview | ∀ (method : String) (direction : Lean.JsonRpc.MessageDirection)
(kinds : Array Lean.Server.Overview.ProtocolExtensionKind✝) (parameterType : Type) (description : String),
sizeOf
{ method := method, direction := direction, kinds := kinds, parameterType := parameterType,
description := description } =
1 + sizeOf method + sizeOf direction + sizeOf kinds + sizeOf parameterType + sizeOf description |
LinearMap.equivOfDetNeZero._proof_3 | Mathlib.LinearAlgebra.Determinant | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module 𝕜 M], SMulCommClass 𝕜 𝕜 M |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.mk.injEq | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | ∀ (varMap : Lean.Meta.KExprMap ℕ) (vars : Array Lean.Expr) (varMap_1 : Lean.Meta.KExprMap ℕ) (vars_1 : Array Lean.Expr),
({ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 }) = (varMap = varMap_1 ∧ vars = vars_1) |
Equiv.subtypeSubtypeEquivSubtype_apply_coe | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_9} {p q : α → Prop} (h : ∀ {x : α}, q x → p x) (a : { x // q ↑x }),
↑((Equiv.subtypeSubtypeEquivSubtype h) a) = ↑↑a |
Subtype.val_prop | Mathlib.Data.Subtype | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), ↑a ∈ S |
CategoryTheory.ObjectProperty.productToFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.StructuredArrow X P.ι → C |
SubMulAction.ofStabilizer.conjMap | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | {G : Type u_1} →
[inst : Group G] →
{α : Type u_2} →
[inst_1 : MulAction G α] →
{g : G} →
{a b : α} →
(hg : b = g • a) →
↥(SubMulAction.ofStabilizer G a) →ₑ[⇑(MulAction.stabilizerEquivStabilizer hg)]
↥(SubMulAction.ofStabilizer G b) |
_private.Mathlib.RingTheory.Ideal.Lattice.0.Ideal.eq_top_of_isUnit_mem.match_1_1 | Mathlib.RingTheory.Ideal.Lattice | ∀ {α : Type u_1} [inst : Semiring α] {x : α} (motive : (∃ b, b * x = 1) → Prop) (x_1 : ∃ b, b * x = 1),
(∀ (y : α) (hy : y * x = 1), motive ⋯) → motive x_1 |
CategoryTheory.Bicategory.rightAdjointSquareConjugate.vcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
{g : a ⟶ c} →
{h : b ⟶ d} →
{r₁ : b ⟶ a} →
{r₂ r₃ : d ⟶ c} →
(CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₂) →
(r₂ ⟶ r₃) → (CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₃) |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_coe_sort._simp_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Nontrivial α = Set.univ.Nontrivial |
Filter.filter_eq_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α}, f = g ↔ f.sets = g.sets |
Hyperreal.archimedeanClassMk_nonneg_of_tendsto | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, Filter.Germ.Tendsto x (nhds r) → 0 ≤ ArchimedeanClass.mk x |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_mem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed sᶜ = IsOpen s |
ProbabilityTheory.Kernel.eq_rnDeriv_measure | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η ξ : ProbabilityTheory.Kernel α γ}
{f : α → γ → ENNReal} [inst : ProbabilityTheory.IsFiniteKernel η],
κ = η.withDensity f + ξ →
Measurable (Function.uncurry f) → ∀ (a : α), (ξ a).MutuallySingular (η a) → f a =ᵐ[η a] (κ a).rnDeriv (η a) |
Multiset.cons_lt_cons_iff._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α} {a : α}, (a ::ₘ s < a ::ₘ t) = (s < t) |
SemilatInfCat.hasForgetToPartOrd._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y Z : SemilatInfCat} (f : X ⟶ Y) (g : Y ⟶ Z),
PartOrd.ofHom { toFun := ⇑(CategoryTheory.CategoryStruct.comp f g).toInfHom, monotone' := ⋯ } =
CategoryTheory.CategoryStruct.comp (PartOrd.ofHom { toFun := ⇑f.toInfHom, monotone' := ⋯ })
(PartOrd.ofHom { toFun := ⇑g.toInfHom, monotone' := ⋯ }) |
CommMonCat.coyonedaType._proof_4 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ),
{
app := fun N =>
CommMonCat.ofHom
(Pi.monoidHom fun i => Pi.evalMonoidHom (fun a => ↑N) ((CategoryTheory.CategoryStruct.id X).unop i)),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
{ obj := fun M => CommMonCat.of (Opposite.unop X → ↑M),
map := fun {X_1 Y} f =>
CommMonCat.ofHom (Pi.monoidHom fun i => (CommMonCat.Hom.hom f).comp (Pi.evalMonoidHom (fun a => ↑X_1) i)),
map_id := ⋯, map_comp := ⋯ } |
Subgroup._sizeOf_inst | Mathlib.Algebra.Group.Subgroup.Defs | (G : Type u_3) → {inst : Group G} → [SizeOf G] → SizeOf (Subgroup G) |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_3 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_8 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] {η : R} {P : Polynomial R} (d : ℕ),
(∀ m < d + 1,
∀ {P : Polynomial R},
P ≠ 0 → P.natDegree = m → P.signVariations + 1 ≤ ((Polynomial.X - Polynomial.C η) * P).signVariations) →
P.eraseLead.natDegree < d + 1 →
¬P.eraseLead = 0 →
((Polynomial.X - Polynomial.C η) * P).eraseLead.signVariations + 1 =
((Polynomial.X - Polynomial.C η) * P).signVariations →
((Polynomial.X - Polynomial.C η) * P.eraseLead).signVariations ≤
((Polynomial.X - Polynomial.C η) * P).eraseLead.signVariations →
P.signVariations + 1 ≤ ((Polynomial.X - Polynomial.C η) * P).signVariations |
Ordinal.cof_le_card | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (o : Ordinal.{u_1}), o.cof ≤ o.card |
BitVec.clzAuxRec_eq_clzAuxRec_of_le | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, w - 1 ≤ n → x.clzAuxRec n = x.clzAuxRec (w - 1) |
ModuleCat.rec | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] →
{motive : ModuleCat R → Sort u_1} →
((carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
motive { carrier := carrier, isAddCommGroup := isAddCommGroup, isModule := isModule }) →
(t : ModuleCat R) → motive t |
Filter.tendsto_atTop_pure | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : OrderTop α] (f : α → β),
Filter.Tendsto f Filter.atTop (pure (f ⊤)) |
Lean.Meta.Match.Example.var | Lean.Meta.Match.Basic | Lean.FVarId → Lean.Meta.Match.Example |
GradedTensorProduct.lift._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} [inst : CommRing R] {C : Type u_2} [inst_1 : Ring C] [inst_2 : Algebra R C], SMulCommClass R C C |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_156 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
_private.Std.Time.Zoned.Offset.0.Std.Time.TimeZone.instDecidableEqOffset.decEq._proof_2 | Std.Time.Zoned.Offset | ∀ (a b : Std.Time.Second.Offset), ¬a = b → { second := a } = { second := b } → False |
Lean.Meta.DSimp.Config.decide | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool |
hasProd_unique._simp_2 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Unique β] (f : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop], HasProd f (f default) L = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.