name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.CountableFilterBasis.rec | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_6} →
{motive : Filter.CountableFilterBasis α → Sort u} →
((toFilterBasis : FilterBasis α) →
(countable : toFilterBasis.sets.Countable) →
motive { toFilterBasis := toFilterBasis, countable := countable }) →
(t : Filter.CountableFilterBasis α) → motive t | false |
Algebra.Extension.homInfinitesimal._proof_5 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(P₁ : Algebra.Extension R A) (P₂ : Algebra.Extension R A) [inst_3 : Algebra.FormallySmooth R P₁.Ring]
(x : P₁.infinitesimal.Ring),
(algebraMap P₂.infinitesimal.Ring A)
((Ideal.Quotient.liftₐ (P₁.ker ^ 2)
... | false |
Std.ExtDHashMap.mem_alter_of_beq | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : Option (β k) → Option (β k)}, (k == k') = true → (k' ∈ m.alter k f ↔ (f (m.get? k)).isSome = true) | true |
CategoryTheory.ShortComplex.leftHomologyFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.leftHomologyFunctor C).obj S = S.leftHomo... | true |
Prefunctor.mapPath._sunfold | Mathlib.Combinatorics.Quiver.Path | {V : Type u₁} →
[inst : Quiver V] →
{W : Type u₂} → [inst_1 : Quiver W] → (F : V ⥤q W) → {a b : V} → Quiver.Path a b → Quiver.Path (F.obj a) (F.obj b) | false |
List.length_pos_of_sum_pos | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [inst_1 : Preorder M] (L : List M), 0 < L.sum → 0 < L.length | true |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.visitCode._sparseCasesOn_10 | Lean.Compiler.LCNF.StructProjCases | {pu : Lean.Compiler.LCNF.Purity} →
{motive_1 : Lean.Compiler.LCNF.Alt pu → Sort u} →
(t : Lean.Compiler.LCNF.Alt pu) →
((ctorName : Lean.Name) →
(params : Array (Lean.Compiler.LCNF.Param pu)) →
(code : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure... | false |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsClosure.0.CategoryTheory.ObjectProperty.strictLimitsClosureStep_strictLimitsClosureIter_eq_self._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : CategoryTheory.ObjectProperty C) (X : C),
(P ⊔ Q) X = (P X ∨ Q X) | false |
CategoryTheory.Congruence.compLeft | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {r : HomRel C}
[self : CategoryTheory.HomRel.IsStableUnderPrecomp r] {X Y Z : C} (f : X ⟶ Y) {g g' : Y ⟶ Z},
r g g' → r (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.comp f g') | true |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.StrongHomClass.realize_boundedFormula._simp_1_7 | Mathlib.ModelTheory.Semantics | ∀ {γ : Sort u_1} {δ : Sort u_2} {α : Type u_3} {β : Type u_4} (f : γ → δ) (g : α → γ) (h : β → γ),
Sum.elim (f ∘ g) (f ∘ h) = f ∘ Sum.elim g h | false |
_private.Lean.Compiler.LCNF.Probing.0.Lean.Compiler.LCNF.Probe.filterByFun.go | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(Lean.Compiler.LCNF.FunDecl pu → Lean.Compiler.LCNF.CompilerM Bool) →
Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.CompilerM Bool | true |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.tryThisProvider._sparseCasesOn_6 | Lean.Meta.Tactic.TryThis | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CustomInfo) → motive (Lean.Elab.Info.ofCustomInfo i)) →
(Nat.hasNotBit 1024 t.ctorIdx → motive t) → motive t | false |
ContDiffBump.mk.injEq | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} {c : E} (rIn rOut : ℝ) (rIn_pos : 0 < rIn) (rIn_lt_rOut : rIn < rOut) (rIn_1 rOut_1 : ℝ)
(rIn_pos_1 : 0 < rIn_1) (rIn_lt_rOut_1 : rIn_1 < rOut_1),
({ rIn := rIn, rOut := rOut, rIn_pos := rIn_pos, rIn_lt_rOut := rIn_lt_rOut } =
{ rIn := rIn_1, rOut := rOut_1, rIn_pos := rIn_pos_1, rIn_lt_rOut ... | true |
CategoryTheory.Limits.piConst | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasProducts C] → CategoryTheory.Functor C (CategoryTheory.Functor Type wᵒᵖ C) | true |
_private.Lean.Data.RBMap.0.Lean.RBNode.max.match_1 | Lean.Data.RBMap | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Lean.RBNode α β → Sort u_3) →
(x : Lean.RBNode α β) →
(Unit → motive Lean.RBNode.leaf) →
((color : Lean.RBColor) →
(lchild : Lean.RBNode α β) →
(k : α) → (v : β k) → motive (Lean.RBNode.node color lchild k v Lean... | false |
ProbabilityTheory.Kernel.measurable_singularPart | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] (κ η : ProbabilityTheory.Kernel α γ)
[ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η],
Measurable fun a => (κ a).singularPart (η a) | true |
MeasureTheory.continuousOn_setToFun_of_dominated | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : CompleteSpace F] {T : Set α → E →L[ℝ] F} {C : ℝ} {X : Type u_7} [inst_5 : TopologicalSpac... | true |
WittVector.IsPoly | Mathlib.RingTheory.WittVector.IsPoly | (p : ℕ) → (⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R) → Prop | true |
CategoryTheory.Limits.Fork.isoForkOfι_hom_hom | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (c : CategoryTheory.Limits.Fork f g),
c.isoForkOfι.hom.hom = CategoryTheory.CategoryStruct.id c.pt | true |
Finset.not_isDiag_mk_of_mem_offDiag | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α} {a b : α}, (a, b) ∈ s.offDiag → ¬s(a, b).IsDiag | true |
Std.DTreeMap.minKey?_eq_head?_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t.minKey? = t.keys.head? | true |
Submonoid.pointwiseMulAction._proof_1 | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {α : Type u_2} {M : Type u_1} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction α M]
(S : Submonoid M), 1 • S = S | false |
TestFunction.Simps.coe | Mathlib.Analysis.Distribution.TestFunction | {E : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_4} →
[inst_2 : NormedAddCommGroup F] → [inst_3 : NormedSpace ℝ F] → {n : ℕ∞} → TestFunction Ω F n → E → F | true |
zsmulRec.eq_2 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {G : Type u_1} [inst : Zero G] [inst_1 : Add G] [inst_2 : Neg G] (nsmul : ℕ → G → G) (x : G) (n : ℕ),
zsmulRec nsmul (Int.negSucc n) x = -nsmul n.succ x | true |
instLawfulCommIdentityUSizeHMulOfNat | Init.Data.UInt.Lemmas | Std.LawfulCommIdentity (fun x1 x2 => x1 * x2) 1 | true |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | false |
SSet.stdSimplex.coe_edge_down_toOrderHom | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ (n : ℕ) (a b : Fin (n + 1)) (hab : a ≤ b),
⇑(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.edge n a b hab).down) = ![a, b] | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.logDeriv_sineTerm_eq_cotTerm._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
Set.finite_mem_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} (s : Finset α), {a | a ∈ s}.Finite | true |
_private.Mathlib.Data.QPF.Multivariate.Constructions.Sigma.0.MvQPF.Pi.abs.match_1.splitter | Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {n : ℕ} →
{A : Type u_1} →
(F : A → TypeVec.{u_1} n → Type u_1) →
[inst : (α : A) → MvQPF (F α)] →
⦃α : TypeVec.{u_1} n⦄ →
(motive : ↑(MvQPF.Pi.P F) α → Sort u_2) →
(x : ↑(MvQPF.Pi.P F) α) →
((a : (MvQPF.Pi.P F).A) → (f : ((MvQPF.Pi.P F).B a).Arrow α) → motive ⟨a,... | true |
Std.DTreeMap.Internal.RccSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.RccSliceData α β} →
{α' : Type u} →
{β' : α' → Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.RccSliceData α' β'} →
α = α' → ... | false |
AddCon.prod.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (c : AddCon M) (d : AddCon N),
c.prod d = { toSetoid := c.prod d.toSetoid, add' := ⋯ } | true |
CategoryTheory.Bicategory.Adj.forget₁._proof_3 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {f g h : a ⟶ b}
(η : f ⟶ g) (θ : g ⟶ h), (CategoryTheory.CategoryStruct.comp η θ).τl = CategoryTheory.CategoryStruct.comp η.τl θ.τl | false |
List.min_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {l : List α} (hl : l ≠ []), l.min hl ∈ l | true |
_private.Mathlib.Topology.Algebra.Group.Basic.0.IsTopologicalGroup.exists_antitone_basis_nhds_one._simp_1_6 | Mathlib.Topology.Algebra.Group.Basic | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | false |
ChevalleyThm.MvPolynomialC.numBound._mutual._proof_1 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | WellFounded (invImage (fun x => PSum.casesOn x (fun a => (a, 0)) fun a => (a, 1)) Prod.instWellFoundedRelation).1 | false |
CategoryTheory.MorphismProperty.IsWeakFactorizationSystem.rlp | Mathlib.CategoryTheory.MorphismProperty.WeakFactorizationSystem | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W₁ W₂ : CategoryTheory.MorphismProperty C}
[self : W₁.IsWeakFactorizationSystem W₂], W₁.rlp = W₂ | true |
irrational_div_intCast_iff | Mathlib.NumberTheory.Real.Irrational | ∀ {m : ℤ} {x : ℝ}, Irrational (x / ↑m) ↔ m ≠ 0 ∧ Irrational x | true |
Char.quoteCore | Init.Data.Repr | Char → optParam Bool false → String | true |
_private.Lean.Compiler.IR.Format.0.Lean.IR.formatFnBody.loop | Lean.Compiler.IR.Format | ℕ → Lean.IR.FnBody → Std.Format | true |
CategoryTheory.Functor.pointwiseRightKanExtension_lift_app | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) [inst_3 : L.HasPointwiseRightKanExtension F]
(G : CategoryT... | true |
Turing.PartrecToTM2.contSupp_fix | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.contSupp (Turing.PartrecToTM2.Cont'.fix f k) =
Turing.PartrecToTM2.codeSupp f (Turing.PartrecToTM2.Cont'.fix f k) | true |
Real.ofDigitsTerm_nonneg | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, 0 ≤ Real.ofDigitsTerm digits n | true |
CategoryTheory.Cat.FreeRefl.homMk | Mathlib.CategoryTheory.Category.ReflQuiv | {V : Type u_1} →
[inst : CategoryTheory.ReflQuiver V] →
{v w : V} → (v ⟶ w) → (CategoryTheory.Cat.FreeRefl.mk v ⟶ CategoryTheory.Cat.FreeRefl.mk w) | true |
Lean.Widget.instRpcEncodableGetGoToLocationParams.enc._@.Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | Lean.Widget.GetGoToLocationParams → StateM Lean.Server.RpcObjectStore Lean.Json | false |
nodup_permsOfList | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α}, l.Nodup → (permsOfList l).Nodup | true |
_private.Lean.Meta.Sym.Simp.Main.0.Lean.Meta.Sym.Simp.simpImpl._sparseCasesOn_1 | Lean.Meta.Sym.Simp.Main | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.emod_lt_of_neg._proof_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ} (b' : ℕ), Int.negSucc b' < 0 → ¬0 < ↑b' + 1 → False | false |
TopCat.PrelocalPredicate.sheafify | Mathlib.Topology.Sheaves.LocalPredicate | {X : TopCat} → {T : ↑X → Type u_2} → TopCat.PrelocalPredicate T → TopCat.LocalPredicate T | true |
HasDerivWithinAt.cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {f : ℝ → ℝ} {f' x : ℝ} {s : Set ℝ},
HasDerivWithinAt f f' s x → HasDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') s x | true |
AddMonoidAlgebra.infDegree_withTop_some_comp | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
{D : A → T} {s : AddMonoidAlgebra R A},
s.support.Nonempty → AddMonoidAlgebra.infDegree (WithTop.some ∘ D) s = ↑(AddMonoidAlgebra.infDegree D s) | true |
_private.Mathlib.CategoryTheory.Sites.Pretopology.0.CategoryTheory.Pretopology.instInfSet._simp_2 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
AlgCat.limitSemiring._proof_12 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(a b : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget... | false |
add_tsub_tsub_cancel | Mathlib.Algebra.Order.Sub.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [ExistsAddOfLE α] [AddLeftMono α]
[inst_4 : Sub α] [OrderedSub α] {a b c : α} [AddLeftReflectLE α], c ≤ a → a + b - (a - c) = b + c | true |
MeasureTheory.MeasurePreserving.integral_comp | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {β : Type u_6} {x : MeasurableSpace β} {f : α → β} {ν : MeasureTheory.Measure β},
MeasureTheory.MeasurePreserving f μ ν →
MeasurableEmbedding f → ∀ (g : β → G), ∫ (x : α... | true |
Decidable.iff_congr_right | Init.PropLemmas | ∀ {P Q R : Prop} [Decidable P] [Decidable Q] [Decidable R], ((P ↔ Q) ↔ (P ↔ R)) ↔ (Q ↔ R) | true |
instSemiringTensorAlgebra._aux_24 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | (R : Type u_1) →
[inst : CommSemiring R] → (M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → ℕ → TensorAlgebra R M | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.«term↑ₐ_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.ParserDescr | true |
Multiset.range.eq_1 | Mathlib.Data.Multiset.Range | ∀ (n : ℕ), Multiset.range n = ↑(List.range n) | true |
Algebra.algebraMapSubmonoid_le_comap | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (M : Submonoid R)
{B : Type w} [inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
Algebra.algebraMapSubmonoid A M ≤ Submonoid.comap f.toRingHom (Algebra.algebraMapSubmonoid B M) | true |
UInt16.and_assoc | Init.Data.UInt.Bitwise | ∀ (a b c : UInt16), a &&& b &&& c = a &&& (b &&& c) | true |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_one_sub._simp_1_3 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
WithConv.toConv.injEq | Mathlib.Algebra.WithConv | ∀ {A : Sort u_1} (ofConv ofConv_1 : A), (WithConv.toConv ofConv = WithConv.toConv ofConv_1) = (ofConv = ofConv_1) | true |
BddAbove.isBoundedUnder_of_range | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] {f : Filter β} {u : β → α},
BddAbove (Set.range u) → Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u | true |
intervalIntegrable_of_odd₀ | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E},
(∀ (x : ℝ), -f x = f (-x)) →
(∀ (x : ℝ), 0 < x → IntervalIntegrable f MeasureTheory.volume 0 x) →
∀ {t : ℝ},
autoParam (‖f (min 0 t)‖ₑ ≠ ⊤) intervalIntegrable_of_odd₀._auto_1 →
IntervalIntegrable f MeasureTheory.volume 0 t | true |
_private.Lean.Elab.PreDefinition.MkInhabitant.0.Lean.Elab.mkInhabitantForAux? | Lean.Elab.PreDefinition.MkInhabitant | Array Lean.Expr → Array Lean.Expr → Lean.Expr → Bool → Lean.MetaM (Option Lean.Expr) | true |
continuous_neg_iff._simp_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) = Continuous f | false |
Lean.Meta.Match.instInhabitedProblem.default | Lean.Meta.Match.Basic | Lean.Meta.Match.Problem | true |
Complex.I_ne_zero._simp_1 | Mathlib.Data.Complex.Basic | (Complex.I = 0) = False | false |
Array.setIfInBounds_append_left | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {i : ℕ} {x : α},
i < xs.size → (xs ++ ys).setIfInBounds i x = xs.setIfInBounds i x ++ ys | true |
Mathlib.Tactic.ITauto.instInhabitedAndKind | Mathlib.Tactic.ITauto | Inhabited Mathlib.Tactic.ITauto.AndKind | true |
Real.noConfusionType | Mathlib.Data.Real.Basic | Sort u → ℝ → ℝ → Sort u | false |
genLoopEquivOfUnique._proof_7 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [Unique N] (p : ↑(GenLoop N X x)),
(p fun x => 1) = x | false |
ProbabilityTheory.Kernel.isSFiniteKernel_prodMkRight_unit | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.prodMkRight Unit κ) ↔ ProbabilityTheory.IsSFiniteKernel κ | true |
IsSpectralMap.mk | Mathlib.Topology.Spectral.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
Continuous f → (∀ ⦃s : Set β⦄, IsOpen s → IsCompact s → IsCompact (f ⁻¹' s)) → IsSpectralMap f | true |
ExceptT.pure | Init.Control.Except | {ε : Type u} → {m : Type u → Type v} → [Monad m] → {α : Type u} → α → ExceptT ε m α | true |
hasStrictFDerivAt_apply | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {ι : Type u_6} {F' : ι → Type u_7}
[inst_1 : (i : ι) → NormedAddCommGroup (F' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (F' i)] (i : ι) (f : (i : ι) → F' i),
HasStrictFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f | true |
String.Pos.prev_induction | Init.Data.String.Termination | ∀ {s : String} {C : s.Pos → Prop} (p : s.Pos),
(∀ (x : s.Pos) (h : x ≠ s.startPos), C (x.prev h) → C x) → C s.startPos → C p | true |
Module.dualProdDualEquivDual | Mathlib.LinearAlgebra.Dual.Lemmas | (R : Type u_1) →
(M : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
(M' : Type u_4) →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] → (Module.Dual R M × Module.Dual R M') ≃ₗ[R] Module.Dual R (M × M') | true |
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find._unsafe_rec | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (α → m (Option β)) → (as : Array α) → (i : ℕ) → i ≤ as.size → m (Option β) | false |
Std.DHashMap.Raw.any_eq_true_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
{p : (a : α) → β a → Bool}, m.WF → (m.any p = true ↔ ∃ a, ∃ (h : m.contains a = true), p a (m.get a h) = true) | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_inv_left._simp_1_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {g h : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h) = (g = h) | false |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.initFn._proof_1._@.Mathlib.Tactic.GCongr.Core.2213018204._hygCtx._hyg.2 | Mathlib.Tactic.GCongr.Core | ∀ (xs : Array Lean.Expr), xs.size ≤ xs.size | false |
Std.Do.SPred.or_comm | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q : Std.Do.SPred σs}, P ∨ Q ⊣⊢ₛ Q ∨ P | true |
Module.Basis.addHaar_self | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {E : Type u_3} [inst : Fintype ι] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (b : Module.Basis ι ℝ E), b.addHaar (parallelepiped ⇑b) = 1 | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.subst.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{x : Int.Linear.Var} →
{c₁ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr} →
{c₂ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr} →
{x' : Int.Linear.Var} →
{c₁' : Lean.Meta.Grind.Arith.Cutsat.EqCnstr} →
{c₂' : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr} →
Lean.Meta.... | false |
Function.injective_of_isPartialInv_right | Mathlib.Logic.Function.Basic | ∀ {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α},
Function.IsPartialInv f g → ∀ (x y : β), ∀ b ∈ g x, b ∈ g y → x = y | true |
Ideal.one_eq_top | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R], 1 = ⊤ | true |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ext_iff_isBase.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}
(motive : (M₁.E = M₂.E ∧ ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)) → Prop)
(x : M₁.E = M₂.E ∧ ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)),
(∀ (hE : M₁.E = M₂.E) (h : ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)), motive ⋯) → motive x | false |
CategoryTheory.CostructuredArrow.instEssSurjCompObjPostOfFull | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (S : C) [G.Full], (CategoryTheory.CostructuredArrow.post F G S).EssSur... | true |
ContMDiffSection.coeFn_mk | Mathlib.Geometry.Manifold.VectorBundle.SmoothSection | ∀ {𝕜 : 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 : NormedAddCommG... | true |
NNReal.agm_eq_ciSup | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agm y = ⨆ n, (x.agmSequences y n).1 | true |
CoalgCat.MonoidalCategory.inducingFunctorData._proof_7 | Mathlib.Algebra.Category.CoalgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X Y Z : CoalgCat R),
(CategoryTheory.forget₂ (CoalgCat R) (ModuleCat R)).map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom =
(((CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.forget₂ (Coal... | false |
ContinuousAlgHom.instContinuousMapClass | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B],
ContinuousMapClass (A →A[R] B) A B | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs.match_3 | Mathlib.Tactic.Linarith.Preprocessing | (motive : Lean.Expr × Bool → Sort u_1) →
(x : Lean.Expr × Bool) → ((e : Lean.Expr) → (is_sq : Bool) → motive (e, is_sq)) → motive x | false |
Std.DHashMap.Raw.Const.get!_alter_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k : α} [inst_4 : Inhabited β] {f : Option β → Option β},
m.WF → Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.Const.alter m k f) k = (f (Std.DHashMap.Raw.Const.get? m k)).ge... | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_insertListIfNewUnit_le._simp_1_4 | Std.Data.Internal.List.Associative | ∀ (n : ℕ), (n ≤ n) = True | false |
ContinuousLinearMap.toWOT._proof_2 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₂ : Type u_1} [inst : NormedField 𝕜₂] (F : Type u_2) [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜₂ F],
SMulCommClass 𝕜₂ 𝕜₂ F | false |
Lean.Grind.AC.Expr.toSeq'.match_1.congr_eq_1 | Init.Grind.AC | ∀ (motive : Lean.Grind.AC.Expr → Sort u_1) (e : Lean.Grind.AC.Expr)
(h_1 : (x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Expr.var x))
(h_2 : (a b : Lean.Grind.AC.Expr) → motive (a.op b)) (x : Lean.Grind.AC.Var),
e = Lean.Grind.AC.Expr.var x →
(match e with
| Lean.Grind.AC.Expr.var x => h_1 x
| a... | true |
Lean.Server.Watchdog.ReferenceRequestContext.mk.injEq | Lean.Server.Watchdog | ∀ (fileWorkerMods : Std.TreeMap Lean.Lsp.DocumentUri Lean.Name compare) (references : Lean.Server.References)
(fileWorkerMods_1 : Std.TreeMap Lean.Lsp.DocumentUri Lean.Name compare) (references_1 : Lean.Server.References),
({ fileWorkerMods := fileWorkerMods, references := references } =
{ fileWorkerMods := f... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.