name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor.0.CategoryTheory.MonoidalCategory.DayFunctor.hom_ext._proof_1_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {V : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] {F G : CategoryTheory.MonoidalCategory.DayFunctor C V}
(natTrans natTrans_1 : F.functor ⟶ G.functo... | null | false |
CategoryTheory.Adjunction.mkOfUnitCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : CategoryTheory.Adjunction.CoreUnitCounit F G) (Y : D),
CategoryTheory.CategoryStruct.comp (adj.unit.app (G.obj Y)) ... | null | false |
AEMeasurable.snd | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {m0 : MeasurableSpace α} [inst : MeasurableSpace β]
[inst_1 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {f : α → β × γ},
AEMeasurable f μ → AEMeasurable (fun x => (f x).2) μ | null | true |
not_injective_infinite_finite | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_3} {β : Sort u_4} [Infinite α] [Finite β] (f : α → β), ¬Function.Injective f | null | true |
Lean.Parser.Command.importPath | Lean.Parser.Command | Lean.Parser.Parser | `#import_path Foo` prints the transitive import chain that brings the declaration `Foo`
into the current file's scope.
| true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w n : ℕ} (aig : Std.Sat.AIG α) (distance : aig.RefVec n)
(curr : ℕ) (acc : aig.RefVec w),
curr < n - 1 →
∀
(this :
aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.twoPowShift aig
{ n := n, ... | null | false |
IsSl2Triple.HasPrimitiveVectorWith.mk._flat_ctor | Mathlib.Algebra.Lie.Sl2 | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {h e f : L} {t : IsSl2Triple h e f} {m : M} {μ : R},
m ≠ 0 → ⁅h, m⁆ = μ • m → ⁅e, m⁆ = 0 → t.HasPrimitiveVectorWith m μ | null | false |
toIcoDiv_ofNat_mul_add | 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 : ℕ) [inst_4 : m.AtLeastTwo],
toIcoDiv hp a (OfNat.ofNat m * p + b) = OfNat.ofNat m + toIcoDiv hp a b | null | true |
Stream'.Seq.BisimO._sparseCasesOn_2.else_eq | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Stream'.Seq.BisimO._sparseCasesOn_2 t some «else» = «else» h | null | false |
FreeAddGroup.instAddGroup._proof_8 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (n : ℕ) (a : FreeAddGroup α), ↑n.succ • a = ↑n • a + a | null | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_InfinitePlace_Ramification___unexpand_MulAction_stabilizer_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | Lean.PrettyPrinter.Unexpander | null | false |
ZSpan.quotientEquiv_apply_mk | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) [inst_3 : LinearOrder K] [inst_4 : IsStrictOrderedRing K]
[inst_5 : FloorRing K] [inst_6 : Fintype ι] (x : E),
(ZSpan.quotientEquiv b) (Submodule.Quotient.mk x)... | null | true |
iteratedDeriv_fun_const_zero | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜}, iteratedDeriv n (fun x => 0) x = 0 | null | true |
SeparationQuotient.instCommSemigroup._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : CommSemigroup M] [inst_2 : ContinuousMul M]
(a b : SeparationQuotient M), a * b = b * a | null | false |
Bornology.isCobounded_compl_iff | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s : Set α}, Bornology.IsCobounded sᶜ ↔ Bornology.IsBounded s | null | true |
CategoryTheory.Mon.instZeroHom | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] → (M N : CategoryTheory.Mon D) → Zero (M ⟶ N) | null | true |
Lean.Elab.Do.ControlStack.mk.injEq | Lean.Elab.Do.Control | ∀ (description : Unit → Lean.MessageData) (m : Lean.Elab.Do.DoElabM Lean.Expr)
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr)
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont)
(description_1 : Unit → Lean.MessageData) (m_1 : Lean.Elab.Do.DoElabM Lean.Expr)
(stM... | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitQuotLift | Lean.Compiler.LCNF.ToLCNF | Lean.Expr → Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | null | true |
Batteries.Tactic.tactic_ | Batteries.Tactic.Init | Lean.ParserDescr | `_` in tactic position acts like the `done` tactic: it fails and gives the list
of goals if there are any. It is useful as a placeholder after starting a tactic block
such as `by _` to make it syntactically correct and show the current goal.
| true |
Lean.Compiler.LCNF.Check.Pure.checkParams | Lean.Compiler.LCNF.Check | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.Check.Pure.CheckM Unit | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.intervalIntegrable_subset_of_integrableOn | Mathlib.Analysis.SumIntegralComparisons | ∀ {x₀ : ℝ} {a : ℕ} {f : ℝ → ℝ},
MeasureTheory.IntegrableOn f (Set.Icc x₀ (x₀ + ↑a)) MeasureTheory.volume →
∀ (k : ℕ), k + 1 ≤ a → IntervalIntegrable f MeasureTheory.volume (x₀ + ↑k) (x₀ + ↑(k + 1)) | null | true |
_private.Mathlib.Geometry.Convex.Set.0.Convexity.IsConvexSet.singleton._simp_1_2 | Mathlib.Geometry.Convex.Set | ∀ {α : Type u_1} {s : Finset α} {a : α}, (↑s ⊆ {a}) = (s ⊆ {a}) | null | false |
ArithmeticFunction.instAlgebra._proof_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (x : R)
(f g : ArithmeticFunction S), x • f * g = x • (f * g) | null | false |
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | ∀ {Γ₀ : Type v} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_1) [inst_1 : Field K] (v : Valuation K Γ₀),
v.leSubmodule 0 = ⊥ | null | true |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | {obj : Type u} → [toQuiver : Quiver obj] → ((X : obj) → X ⟶ X) → CategoryTheory.ReflQuiver obj | null | true |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | Function.Bijective Real.arsinh | null | true |
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace ℝ E] [inst_4 : NormedSpace ℂ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℂ 𝕜 F] [inst_7 : FiniteDimensional ℝ E] [inst_8 : MeasurableSpace E] [in... | null | true |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : Mᵃᵒᵖ →+ Nᵃᵒᵖ) (a : M),
(AddMonoidHom.op.symm f) a = (AddOpposite.unop ∘ ⇑f ∘ AddOpposite.op) a | null | true |
Filter.eventuallyEmptyOrUniv_iff' | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {l : Filter α} {s : Set α}, Filter.EventuallyEmptyOrUniv s l ↔ s =ᶠ[l] ∅ ∨ s =ᶠ[l] Set.univ | null | true |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (toSubsemigroup : Subsemigroup M) (one_mem' : 1 ∈ toSubsemigroup.carrier),
({ toSubsemigroup := toSubsemigroup, one_mem' := one_mem' } = ⊤) = (toSubsemigroup = ⊤) | null | false |
Lean.Compiler.LCNF.CtorFieldInfo.object.inj | Lean.Compiler.LCNF.ToImpureType | ∀ {i : ℕ} {type : Lean.Expr} {i_1 : ℕ} {type_1 : Lean.Expr},
Lean.Compiler.LCNF.CtorFieldInfo.object i type = Lean.Compiler.LCNF.CtorFieldInfo.object i_1 type_1 →
i = i_1 ∧ type = type_1 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.eq_bot_iff_isIsolated._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {v : V}, G.IsIsolated v = (G.neighborSet v = ∅) | null | false |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {γ : Type w} {f : α → β → Option γ} {l : List ((_ : α) × β)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (List.filterMap (fun p => Option.map (fun x => ⟨p.fst, x⟩) (f p.fst p.snd)) l) =
if h : Std.Internal.List.contain... | null | true |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | null | true |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
CategoryTheory.Limits.LimitPresentation J X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →... | null | false |
_private.Mathlib.Basic.Unique.0.Unique.subsingleton_unique'.match_1_1 | Mathlib.Basic.Unique | ∀ {α : Sort u_1} (motive : Unique α → Unique α → Prop) (x x_1 : Unique α),
(∀ (x : α) (h : ∀ (a : α), a = default) (y : α) (uniq : ∀ (a : α), a = default),
motive { default := x, uniq := h } { default := y, uniq := uniq }) →
motive x x_1 | null | false |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {α : Type u_1} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α] {a : α} {f : (i : ι) → κ i → α},
(⨆ i, ⨆ j, f i j ≤ a) = ∀ (i : ι) (j : κ i), f i j ≤ a | null | false |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] {ι : Type u_3} [Finite ι] (f : ι → S),
∃ b, ∀ (i : ι), IsLocalization.IsInteger R (↑b • f i) | We can clear the denominators of a finite indexed family of fractions. | true |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
[∀ (S : CategoryTheory.ShortComplex C), S.ShortExact → (S.ma... | For an additive functor `F : C ⥤ D` between abelian categories, the following are equivalent:
- `F` preserves short exact sequences, i.e. if `0 ⟶ A ⟶ B ⟶ C ⟶ 0` is exact then
`0 ⟶ F(A) ⟶ F(B) ⟶ F(C) ⟶ 0` is exact.
- `F` preserves exact sequences, i.e. if `A ⟶ B ⟶ C` is exact then `F(A) ⟶ F(B) ⟶ F(C)` is exact.
- `F` ... | true |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool} {dropping : Bool},
(Std.IterM.Intermediate.dropWhile P dropping it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterSte... | null | true |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : AddMonoid M] (a : l.Germ M), 0 + a = a | null | false |
LawfulXor.xor_zero | Mathlib.Data.LawfulXor.Basic | ∀ {α : Type u_1} {inst : XorOp α} {inst_1 : Zero α} [self : LawfulXor α] (a : α), a ^^^ 0 = a | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedState →
Lean.Syntax →
Option Lean.Expr →
Bool → List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Term.TermElab) → Lean.Elab.TermElabM Lean.Expr | null | false |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ℝ), f ⁻¹' Metric.closedBall (f x) r = Metric.closedBall x r | null | true |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | {P : Sort u} → {t t' : Lean.Lsp.FileEvent} → t = t' → Lean.Lsp.FileEvent.noConfusionType P t t' | null | false |
WithBot.not_bot_wcovBy | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] [NoMinOrder α] {a : α}, ¬⊥ ⩿ ↑a | null | true |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | ℕ → ℕ → ℕ | null | false |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve... | null | false |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ = (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ | null | false |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {β : Type u_2} {r1 : β → Bool} {r2 : α → β} {f : Std.Sat.CNF α},
Std.Sat.CNF.Sat (r1 ∘ r2) f → Std.Sat.CNF.Sat r1 (Std.Sat.CNF.relabel r2 f) | null | true |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (i : Fin n), ↑i < m | null | false |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (f g : CoheytingHom α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(x : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.fixedNoParam) →
(Unit → motive Lean.Meta.CongrArgKind.eq) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → m... | null | false |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | ∀ {α : Type u} [Countable α], {s | s.Finite}.Countable | **Alias** of `Set.Countable.ofPred_finite`.
---
The set of finite sets in a countable type is countable. | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Lean.Exception.isInterrupt | Lean.Exception | Lean.Exception → Bool | Returns `true` if the exception is an interrupt generated by `checkInterrupted`. | true |
Lean.Grind.isLE | Init.Grind.Offset | ℕ → ℕ → Bool | null | true |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (x : ↥A.principalUnitGroup),
A.unitGroupMulEquiv ⟨↑x, ⋯⟩ ∈ (Units.map ↑(IsLocalRing.residue ↥A)).ker | null | false |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.isInitialIso'_hom_right | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.Arrow C) {I : C}
(i : CategoryTheory.Limits.IsIni... | null | true |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | Type | null | true |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : Group α] → Top (GroupTopology α) | null | true |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (i : ι) (x : X),
(f i) x ≤ 1 | null | true |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Continuous ⇑f | null | false |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ∀ (q : ENNReal), MeasureTheory.MemLp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | (¬True) = False | null | false |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toList = List.drop n it.toList | null | true |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (B : Type u_5) (E : outParam (Type u_6)) (F : outParam (Type u_7)) [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedSpace ℝ F] (n : outParam ℕ∞)
(K : outParam (TopologicalSpace.Compacts E)) [inst_4 : FunLike B E F] [ContDiffMapSupportedInClass B E F n K],
... | null | true |
Std.Http.URI.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} → {t t' : Std.Http.URI} → t = t' → Std.Http.URI.noConfusionType P t t' | null | false |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
(t : Set γ) (f : β × γ → α), ∑' (x : ↑({b} ×ˢ t)), f ↑x = ∑' (c : ↑t), f (b, ↑c) | null | true |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] (S : Set M), S.centralizer.centralizer.centralizer = S.centralizer | null | true |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
[inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : IsBoundedSMul α β], IsBoundedSMul α (SeparationQuotient β) | null | true |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T₁ : CategoryTheory.Monad C} {X Y : T₁.Algebra}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).map f)
(CategoryTheory.Monad.Algebra.isoMk
(Cat... | null | false |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α}, a ∈ t → t.get? a = some (t.getD a fallback) | null | true |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Abelian (CategoryTheory.AsSmall C) | null | true |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeInf α] {s t : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : BoundedOrder α]
[inst_3 : DecidableEq α],
a ∈ upperClosure ↑s → a ∈ upperClosure ↑t → (s ∪ t).truncatedInf a = s.truncatedInf a ⊓ t.truncatedInf a | null | true |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [inst : DivisionRing K],
GenContFract.convs'Aux s (n + 2) = GenContFract.convs'Aux (GenContFract.squashSeq s n) (n + 1) | The auxiliary function `convs'Aux` returns the same value for a sequence and the
corresponding squashed sequence at the squashed position. | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | Lean.Name → Lean.Name → Bool → Bool | null | true |
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.primeHeight.congr_simp | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (I I_1 : Ideal R) (e_I : I = I_1) [hI : I.IsPrime],
Ideal.primeHeight✝ I = Ideal.primeHeight✝ I_1 | null | true |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedRing A] (a : UniformSpace.Completion A), -a + a = 0 | null | false |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | ∀ {as bs : ByteArray} {i j len : ℕ} (hi : i + len ≤ as.size) (hj : j + len ≤ bs.size),
as.extract i (i + len) = bs.extract j (j + len) ↔ ∀ (k : ℕ) (hk : k < len), as[i + k] = bs[j + k] | null | true |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} → Std.Tactic.BVDecide.BVBinPred → BitVec w → BitVec w → Bool | The semantics for `BVBinPred`.
| true |
expandLemma | Mathlib.Tactic.Lemma | Lean.Macro | Implementation of the `lemma` command, by macro expansion to `theorem`. | true |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | ∀ (bs : ByteArray) (_x : (_ : ℕ) ×' List UInt8),
ByteArray.toList.loop._unary bs _x =
PSigma.casesOn _x fun i r =>
if i < bs.size then ByteArray.toList.loop._unary bs ⟨i + 1, bs.get! i :: r⟩ else r.reverse | null | false |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Add (G i)] [∀ (i : ι), TwoUniqueSums (G i)],
TwoUniqueSums ((i : ι) → G i) | null | true |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s₁ s₂ : EuclideanGeometry.Sphere P} {p : P}, s₁.IsExtTangentAt s₂ p → p ∈ s₁ | null | true |
Qq.Impl.isIrrefutablePattern | Qq.Match | Lean.Term → Bool | null | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α],
MeasurableSpace.CountablySeparated α = HasCountableSeparatingOn α MeasurableSet Set.univ | null | false |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (m<...n).toArray[i]! = if i < (n - (m + 1)).toNat then m + 1 + ↑i else 0 | null | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | ∀ (s : String.Slice), ∀ offset ≤ s.rawEndPos, ¬String.Pos.Raw.IsValidForSlice s offset → offset < s.rawEndPos | null | false |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{W : Type u_3} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid W] →
[inst_3 : Module A W] →
{ρ : Representation A G W} →
(toSubmodule : Submodule A W) →
(∀ (g : G) ⦃v : W⦄, v... | null | false |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | ∀ (text : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections : Array (ℕ × Lean.DeclarationRange × Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))
(declarationRange : Lean.DeclarationRange) (text_1 : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections_1 : Array (ℕ × Lean.Declaration... | null | true |
Mathlib.Tactic.DepRewrite.instDecidableLECastMode._proof_1 | Mathlib.Tactic.DepRewrite | ∀ (a b : Mathlib.Tactic.DepRewrite.CastMode), (a.toNat.ble b.toNat).Reflects (a.toNat ≤ b.toNat) | null | false |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | Aesop.ScriptGenerated → Bool | null | true |
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (f : β → α), Filter.liminf f ⊥ = ⊤ | null | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {ι : X → Type u_1} {p : (x : X) → ι x → Prop} {s : (x : X) → ι x → Set X} (x : X) (_t : Set X)
(motive : (∃ i, p x i ∧ s x i ⊆ _t) → Prop) (x_1 : ∃ i, p x i ∧ s x i ⊆ _t),
(∀ (i : ι x) (hp : p x i) (ht : s x i ⊆ _t), motive ⋯) → motive x_1 | null | false |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | ∀ {a b : ℤ}, (a.natAbs ∣ b.natAbs) = (a ∣ b) | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), n + m = 0 → m = -n | null | false |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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) {s : Set E},
ContinuousOn (↑I.symm) s | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G} {h : ↥K}, (h ∈ H.subgroupOf K) = (↑h ∈ H) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.