name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Finset.sum_sum_Ioi_add_eq_sum_sum_off_diag | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : LinearOrder α] [inst_2 : Fintype α]
[inst_3 : LocallyFiniteOrderTop α] [LocallyFiniteOrderBot α] (f : α → α → M),
∑ i, ∑ j > i, (f j i + f i j) = ∑ i, ∑ j ∈ {i}ᶜ, f j i | null | true |
Filter.Germ.liftPred_const_iff._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [l.NeBot] {p : β → Prop} {x : β}, Filter.Germ.LiftPred p ↑x = p x | null | false |
Set.seq.eq_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (s : Set (α → β)) (t : Set α), s.seq t = Set.image2 (fun f => f) s t | null | true |
AddSubmonoid.multiples._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} [inst : AddMonoid A] (x n : A) (i : ℕ), (fun i => i • x) i = n ↔ ((multiplesHom A) x) i = n | null | false |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_13 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
∀ (u v : α),
v ∈ ⋃₀ ↑I →
∀ (u' : α),
v ∈ Set.Ioc u' v →
(Set.Ioc u' v ∪ ⋃₀ ↑(I.erase (Set.Ioc u' v))) \ Set.Ioc u' v = ⋃₀ ↑(I.erase (Set.Ioc u' v)) →
Set.Ioc ... | null | false |
MeasureTheory.aemeasurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Group G] [MeasurableMul₂ G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant] [MeasureTheory.SFinite μ] {f g : G → ENNReal},
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (MeasureTheory.mlconvolution f g μ) μ | The convolution of `AEMeasurable` functions is `AEMeasurable`. | true |
CategoryTheory.SmallObject.functor._proof_11 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
[CategoryTheory.Limits.HasPushouts C]
[inst_2 :
∀ {X S : C} (πX : X ⟶ S),
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIn... | null | false |
LinearEquiv.multilinearMapCongrLeft._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_1} {M₁ : ι → Type u_5} {M₁' : ι → Type u_2} {M₂ : Type u_3} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (... | null | false |
CategoryTheory.Limits.CatCospanTransform.mkIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_10} {B : Type u_6} {C : Type u_1} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_7, u_10} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_4, u_1} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | null | false |
Lean.Elab.Structural.EqnInfo.fixedParamPerms | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → Lean.Elab.FixedParamPerms | null | true |
List.Cursor.at._proof_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} (l : List α) (n : ℕ), List.take n l ++ List.drop n l = l | null | false |
CategoryTheory.Tor._proof_2 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) (X : C),
CategoryTheory.NatTrans.leftDerived
((Category... | null | false |
Nonneg.semiring._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [ZeroLEOneClass α] [inst_3 : PosMulMono α]
(a b c : Nonneg α), a * b * c = a * (b * c) | null | false |
ODE.FunSpace.recOn | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} →
{t₀ : ↑(Set.Icc tmin tmax)} →
{x₀ : E} →
{r L : NNReal} →
{motive : ODE.FunSpace t₀ x₀ r L → Sort u} →
(t : ODE.FunSpace t₀ x₀ r L) →
((toFun : ↑(Set.Icc tmin tmax) → E) →
... | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec | Lean.Meta.Basic | Bool →
Option ℕ →
Lean.MetavarKind →
Array Lean.Expr →
Array Lean.BinderInfo → ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | null | false |
Lean.Parser.Command.ensuresClause.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_emod_unique'._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (-a = -b) = (a = b) | null | false |
SubStarSemigroup.mk | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(toSubsemigroup : Subsemigroup M) →
(∀ {a : M}, a ∈ toSubsemigroup.carrier → star a ∈ toSubsemigroup.carrier) → SubStarSemigroup M | null | true |
Lean.Meta.Grind.Arith.pickUnusedValue | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal → Std.HashMap Lean.Expr ℚ → Lean.Expr → ℤ → Std.HashSet ℤ → ℤ | Returns an integer value `i` for assigning to `e` s.t. adding `e := i` to `a` will not falsify any disequality
and `i` is not in `alreadyUsed`.
| true |
instIsSemitopologicalSemiringMulOpposite | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] [inst_1 : TopologicalSpace R] [IsSemitopologicalSemiring R],
IsSemitopologicalSemiring Rᵐᵒᵖ | null | true |
CategoryTheory.Limits.CreatesFiniteProducts.creates._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | Lean.Syntax | null | false |
Std.TreeMap.Raw.mem_of_mem_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ ∪ t₂ → k ∉ t₁ → k ∈ t₂ | null | true |
AlgebraicGeometry.Scheme.qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | CategoryTheory.Precoverage AlgebraicGeometry.Scheme | The quasi-compact precoverage on the category of schemes is the precoverage
given by quasi-compact covers. The intersection of this precoverage
with the precoverage defined by jointly surjective families of flat morphisms is
the fpqc-precoverage.
| true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_388 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Encodable.fintypeArrowOfEncodable | Mathlib.Logic.Encodable.Pi | {α : Type u_2} → {β : Type u_3} → [Encodable α] → [Fintype α] → [Encodable β] → Encodable (α → β) | If `α` and `β` are encodable and `α` is a fintype, then `α → β` is encodable as well. | true |
continuousOn_tsum | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ}
[inst_2 : TopologicalSpace β] {f : α → β → F} {s : Set β},
(∀ (i : α), ContinuousOn (f i) s) →
Summable u → (∀ (n : α), ∀ x ∈ s, ‖f n x‖ ≤ u n) → ContinuousOn (fun x => ∑' (n : α), f n x) s | An infinite sum of functions with summable sup norm is continuous on a set if each individual
function is. | true |
Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.definition.parenthesizer_299 | Lean.Parser.Command | IO Unit | null | false |
HomotopicalAlgebra.CofibrantObject.instWeakEquivalenceHoCatAppιCompResolutionNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
HomotopicalAlgebra.WeakEquivalence (HomotopicalAlgebra.CofibrantObject.HoCat.ιCompResolutionNatTrans.app X) | null | true |
TopologicalSpace.NonemptyCompacts.dense_setOfPred_finite | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], Dense {K | (↑K).Finite} | null | true |
VectorFourier.hasFDerivAt_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | Main theorem of this section: if both `f` and `x ↦ ‖x‖ * ‖f x‖` are integrable, then the
Fourier transform of `f` has a Fréchet derivative (everywhere in its domain) and its derivative is
the Fourier transform of `smulRight L f`. | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsLE_iff_exists_Ioc_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hu' : w < a), motive ⋯) → motive x | null | false |
Ordinal.toZFSetIso_symm_apply | Mathlib.SetTheory.ZFC.Ordinal | ∀ (x : { x // x.IsOrdinal }), (RelIso.symm Ordinal.toZFSetIso) x = (↑x).rank | null | true |
CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T × T)
{X_1 Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X_1 ⟶ Y),
((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).map g).left = CategoryTheory.Over.Hom.left g.left | null | true |
AnalyticAt.comp₂_analyticWithinAt | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : NormedAddCom... | `AnalyticAt.comp_analyticWithinAt` for functions on product spaces | true |
Batteries.Tactic.triv | Batteries.Tactic.Init | Lean.ParserDescr | Deprecated variant of `trivial`. | true |
Lean.Grind.Linarith.instReprPoly.repr._f | Init.Grind.Ordered.Linarith | (x : Lean.Grind.Linarith.Poly) → Lean.Grind.Linarith.Poly.below (motive := fun x => ℕ → Std.Format) x → ℕ → Std.Format | null | false |
Append.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Append α} → {α' : Type u} → {t' : Append α'} → α = α' → t ≍ t' → Append.noConfusionType P t t' | null | false |
LightProfinite.Extend.cone._proof_2 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Functor LightProfinite C)
(S : LightProfinite) (x x_1 : CategoryTheory.StructuredArrow S FintypeCat.toLightProfinite) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.StructuredA... | null | false |
TendstoUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f + f') (g + g') l s | null | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData._auto_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax | null | false |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_7 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {p : α → Prop} (head : α) (tail : List α), (∀ x ∈ head :: tail, p x) → tail = [] → ∀ x ∈ [], p x | null | false |
CategoryTheory.Quotient.lift | Mathlib.CategoryTheory.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(r : HomRel C) →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
(∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) →
CategoryTheory.Fu... | The induced functor on the quotient category. | true |
PNat.modDivAux | Mathlib.Data.PNat.Defs | ℕ+ → ℕ → ℕ → ℕ+ × ℕ | We define `m % k` and `m / k` in the same way as for `ℕ`
except that when `m = n * k` we take `m % k = k` and
`m / k = n - 1`. This ensures that `m % k` is always positive
and `m = (m % k) + k * (m / k)` in all cases. Later we
define a function `div_exact` which gives the usual `m / k`
in the case where `k` divides `... | true |
SBtw.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} → {t : SBtw α} → {α' : Type u_1} → {t' : SBtw α'} → α = α' → t ≍ t' → SBtw.noConfusionType P t t' | null | false |
SSet.Subcomplex.Pairing.I | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | the set of type (I) simplices | true |
CategoryTheory.shrinkCoyonedaObjObjEquiv_map_app_assoc | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X X' : Cᵒᵖ}
{Y : C} (f : (CategoryTheory.shrinkCoyoneda.{w, v, u}.obj X).obj Y) (g : X ⟶ X') {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.shrinkCoyonedaObjObjEquiv
((... | null | true |
ProbabilityTheory.Kernel.swapLeft_zero | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ}, ProbabilityTheory.Kernel.swapLeft 0 = 0 | null | true |
ContMDiff.compContinuousAlternatingMapCLM | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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_8} [inst_6 : NormedAddComm... | null | true |
AddSubsemigroup.le_op_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] {S₁ : AddSubsemigroup Mᵃᵒᵖ} {S₂ : AddSubsemigroup M}, S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ | null | true |
Metric.mem_thickening_iff_exists_edist_lt | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} (E : Set α) (x : α),
x ∈ Metric.thickening δ E ↔ ∃ z ∈ E, edist x z < ENNReal.ofReal δ | null | true |
DomAddAct.instZeroOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [Zero Mᵃᵒᵖ] → Zero Mᵈᵃᵃ | null | true |
CategoryTheory.ObjectProperty.trW_iff' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
LipschitzWith.lipschitzOnWith | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
{s : Set α}, LipschitzWith K f → LipschitzOnWith K f s | null | true |
Multiset.countP_le_of_le | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Multiset α},
s ≤ t → Multiset.countP p s ≤ Multiset.countP p t | null | true |
CategoryTheory.Functor.OplaxMonoidal.id._proof_2 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X X')))
... | null | false |
iSup_eq_bot | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥ | null | true |
List.dropLast_eq_eraseIdx | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i + 1 = xs.length → xs.dropLast = xs.eraseIdx i | null | true |
Lean.Parser.CacheableParserContext.noConfusion | Lean.Parser.Types | {P : Sort u} →
{t t' : Lean.Parser.CacheableParserContext} → t = t' → Lean.Parser.CacheableParserContext.noConfusionType P t t' | null | false |
_private.Lean.Environment.0.Lean.AsyncConsts.normalizedTrie | Lean.Environment | Lean.AsyncConsts✝ → Lean.NameTrie Lean.AsyncConst✝ | Trie of declaration names without private name prefixes for fast longest-prefix access. | true |
Int.mul_fmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod b = 0 | null | true |
PNat.instMetricSpace._proof_16 | Mathlib.Topology.Instances.PNat | Filter.Tendsto Prod.swap PNat.instMetricSpace._aux_14 PNat.instMetricSpace._aux_14 | null | false |
CategoryTheory.ShortComplex.cyclesMapIso'._proof_2 | 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} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' e.inv h₂ h₁)
... | null | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalWhiskerRightAux.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.HorizontalComp → Mathlib.Tactic.BicategoryLike.Atom₁ → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.HorizontalComp) →
(x_1 : Mathlib.Tactic.BicategoryLike.Atom₁) →
((η : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁... | null | false |
Array.filter_replicate_of_neg | Init.Data.Array.Lemmas | ∀ {stop n : ℕ} {α : Type u_1} {p : α → Bool} {a : α},
stop = n → ¬p a = true → Array.filter p (Array.replicate n a) 0 stop = #[] | null | true |
LieEquiv.invFun | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{L' : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → [inst_3 : LieRing L'] → [inst_4 : LieAlgebra R L'] → (L ≃ₗ⁅R⁆ L') → L' → L | The inverse function of an equivalence of Lie algebras | true |
UniformContinuous.sup_compacts | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β]
{f g : α → TopologicalSpace.Compacts β},
UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x ⊔ g x | null | true |
subset_of_subset_of_eq | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [UsesSetNotationForOrder α] {a b c : α} [inst : LE α], a ⊆ b → b = c → a ⊆ c | Set notation form of `le_of_le_of_eq` | true |
toIcoDiv_add_intCast_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoDiv hp a (b + ↑m * p) = toIcoDiv hp a b + m | null | true |
Set.biInter_subset_biUnion | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s.Nonempty → ∀ {t : α → Set β}, ⋂ x ∈ s, t x ⊆ ⋃ x ∈ s, t x | null | true |
AbstractCompletion.mapEquiv._proof_3 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_3} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_1, u_3} α) {β : Type u_4}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_2, u_4} β) (e : α ≃ᵤ β),
Function.LeftInverse (pkg'.map pkg ⇑e.symm) (pkg.map pkg' ⇑e) | null | false |
SymAlg.addMonoid._proof_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : AddMonoid α], SymAlg.unsym 0 = 0 | null | false |
CategoryTheory.Coyoneda.colimitCocone_pt | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ),
(CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1} | null | true |
DirectSum.instCommSemiringOfNat._proof_7 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommSemiring A] (x : A 0) (x_1 : ℕ),
(DirectSum.of A 0) (x ^ x_1) = (DirectSum.of A 0) x ^ x_1 | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNeg | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (value : BitVec w)
(target : aig.RefVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := target.get idx hidx }⟧ = value.getLsbD idx) →
∀ (idx : ℕ) (hidx : idx < w),
⟦assign,
... | null | true |
Int8.neg_neg | Init.Data.SInt.Lemmas | ∀ {a : Int8}, - -a = a | null | true |
_private.Mathlib.Topology.InductiveDimension.Classes.0.exists_clopen_partition_of_clopen_cover._proof_1_9 | Mathlib.Topology.InductiveDimension.Classes | ∀ {X : Type u_1} {I : Type u_2} {Z D : Option I → Set X} (C' : I → Set X),
Z none ⊆ D none \ ⋃ i, C' i → Z none ⊆ (fun i => Option.casesOn i (D none \ ⋃ i, C' i) C') none | null | false |
Std.Do.Spec.forIn'_rii._proof_3 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α] [inst_3 : Std.PRange.LawfulUpwardEnumerable α] {xs : Std.Rii α} (pref : List α)
(cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → pref ++ [cur] ++ suff = xs.toList | null | false |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.commutator_diag2_transvection._simp_1_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
ProbabilityTheory.binomial_nat | Mathlib.Probability.Distributions.Binomial | ∀ {n : ℕ} {p : ↑unitInterval},
MeasureTheory.Measure.map Nat.cast (ProbabilityTheory.binomial n p) = ProbabilityTheory.binomial n p | null | true |
_private.Mathlib.FieldTheory.Normal.Closure.0.isNormalClosure_normalClosure.match_1 | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_3) (K : Type u_2) (L : Type u_1) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (ne : Nonempty (K →ₐ[F] L)),
(∀ (φ : K →ₐ[F] L), motive ⋯) → motive ne | null | false |
Turing.PartrecToTM2.Λ'.rec | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Λ' → Sort u} →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.move p k₁ k₂ q)) →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k : Turing.PartrecToTM2.K') →
(... | null | false |
WithZero.le_log_of_exp_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {G : Type u_3} [inst : Preorder G] {a : G} [inst_1 : AddGroup G] {x : WithZero (Multiplicative G)},
WithZero.exp a ≤ x → a ≤ x.log | null | true |
String.Slice.endsWith_string_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice}, s.endsWith pat = true ↔ pat.toList <:+ s.copy.toList | null | true |
Rep.FiniteCyclicGroup.groupHomologyIsoOdd._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G)
(g : G), (Rep.FiniteCyclicGroup.normHomCompSub A g).HasHomology | null | false |
EReal.neTopBotEquivReal._proof_7 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (fun x => (↑x).toReal) ((fun x => ⟨↑x, ⋯⟩) x) = x | null | false |
ArchimedeanClass.FiniteResidueField.instLinearOrder._aux_1 | Mathlib.Algebra.Order.Ring.StandardPart | {K : Type u_1} →
[inst : LinearOrder K] →
[inst_1 : Field K] →
[inst_2 : IsOrderedRing K] → ArchimedeanClass.FiniteResidueField K → ArchimedeanClass.FiniteResidueField K → Prop | null | false |
LinearMap.tensorKerBil._proof_6 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe | Mathlib.Tactic.FBinop | FBinopElab.Tree✝ → FBinopElab.SRec → Lean.Elab.TermElabM FBinopElab.Tree✝ | Try to coerce elements in the tree to `maxS` when needed. | true |
max_le_max_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b : α} (c : α), a ≤ b → max c a ≤ max c b | null | true |
Mathlib.Meta.FunProp.FunctionData.casesOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.FunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionData) →
((lctx : Lean.LocalContext) →
(insts : Lean.LocalInstances) →
(fn : Lean.Expr) →
(args : Array Mathlib.Meta.FunProp.Mor.Arg) →
(mainVar : Lean.Expr) →
(main... | null | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toArray_roc_eq_ite._proof_1_2 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, ¬m + 1 < n + 1 → ¬n < m + 1 → False | null | false |
FourierSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransform E F],
(∀ (r : R) (f : E), FourierTransform.fourier (r • f) = r • FourierTransform.fourier f) → FourierSMul R E F | null | false |
Subfield.relfinrank_map_map | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {L : Type w} [inst_1 : Field L] (A B : Subfield E) (f : E →+* L),
(Subfield.map f A).relfinrank (Subfield.map f B) = A.relfinrank B | null | true |
DistLat.Hom._mkInternal.inj | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} {hom' hom'_1 : LatticeHom ↑X ↑Y}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | false |
SkewMonoidAlgebra.addHom_ext_iff | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {M : Type u_3} [inst_1 : AddZeroClass M]
{f g : SkewMonoidAlgebra k G →+ M},
f = g ↔ ∀ (a : G) (b : k), f (SkewMonoidAlgebra.single a b) = g (SkewMonoidAlgebra.single a b) | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) (decVar : Lean.FVarId) (h : Lean.Meta.Grind.Arith.Cutsat.UnsatProof)
(decVars : Array Lean.FVarId),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit c₁ decVar h decVars) =
1 + sizeOf c₁ + sizeOf decVar + sizeOf h + sizeOf decVars | null | true |
Std.Internal.List.getValueCast_modifyKey._proof_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.containsKey k' (Std.Internal.List.modifyKey k f l) = true →
Std.Internal.List.containsKey k' l = true | null | false |
Lean.Meta.Grind.Arith.CommRing.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.State → Lean.Meta.Grind.Arith.CommRing.State → Sort u | null | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.measurable_stoppedValue._simp_1_7 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.