name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.mkSimpOnly.match_3 | Lean.Elab.Tactic.Simp | (motive : Bool → Sort u_1) → (post : Bool) → (Unit → motive true) → (Unit → motive false) → motive post | null | false |
TopologicalSpace.gciGenerateFrom._proof_3 | Mathlib.Topology.Order | ∀ (α : Type u_1) (x : (Set (Set α))ᵒᵈ) (x_1 : x ≤ OrderDual.toDual {s | IsOpen s}),
TopologicalSpace.mkOfClosure x ⋯ = TopologicalSpace.generateFrom x | null | false |
Vector.set_append | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {xs : Vector α n} {ys : Vector α m} {i : ℕ} {x : α} (h : i < n + m),
(xs ++ ys).set i x h = if h' : i < n then xs.set i x h' ++ ys else xs ++ ys.set (i - n) x ⋯ | null | true |
Std.Http.Response.ok | Std.Http.Data.Response | Std.Http.Response.Builder | Creates a new HTTP Response builder with the 200 status code.
| true |
RBTree.RBNode.Path.listR.eq_1 | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1}, RBTree.RBNode.Path.root.listR = [] | null | true |
CategoryTheory.IsVanKampenColimit.map_reflective | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {J : Type v'} [inst : CategoryTheory.Category.{u', v'} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} D] [CategoryTheory.Limits.HasColimitsOfShape J C]
{Gl : CategoryTheory.Functor C D} {Gr : CategoryTheory.Functor D C} (adj : Gl ⊣ Gr) [Gr.F... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isSome_maxKey?_of_isSome_maxKey?_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
TopologicalSpace.Compacts.isometry_toCloseds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α], Isometry TopologicalSpace.Compacts.toCloseds | null | true |
Subsemiring.toSemiring._proof_9 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : Semiring R] (s : Subsemiring R) (a b c : ↥s), (a + b) * c = a * c + b * c | null | false |
EisensteinSeries.gammaSetEquiv._proof_4 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Defs | ∀ {N r : ℕ} (a : Fin 2 → ZMod N) [inst : NeZero r] (γ : Matrix.SpecialLinearGroup (Fin 2) ℤ)
(v :
↑(EisensteinSeries.gammaSet N r (Matrix.vecMul a ↑((Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod N))) γ)))),
(fun v => ⟨Matrix.vecMul ↑v ↑γ, ⋯⟩) ((fun v => ⟨Matrix.vecMul ↑v ↑γ⁻¹, ⋯⟩) v) = v | null | false |
Mathlib.Meta.Positivity.pos_of_isNNRat | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n d : ℕ} [inst : Semiring A] [inst_1 : LinearOrder A] [IsStrictOrderedRing A],
Mathlib.Meta.NormNum.IsNNRat e n d → decide (0 < n) = true → 0 < e | null | true |
_private.Mathlib.Topology.WithTopology.0.WithTopology.isClosed_iff._simp_1_2 | Mathlib.Topology.WithTopology | ∀ {X : Type u_1} (t : TopologicalSpace X) {s : Set (WithTopology X t)},
IsOpen s = IsOpen (WithTopology.toTopology t ⁻¹' s) | null | false |
AddCommGroup.freeRank_eq_zero | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommGroup G],
AddMonoid.IsTorsion G → ∀ [inst_1 : AddGroup.FG G], AddCommGroup.freeRank G = 0 | null | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.isNatProp._sparseCasesOn_2 | Mathlib.Tactic.Linarith.Preprocessing | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof?.go._f | Lean.Meta.Tactic.Grind.Split | (proof : Lean.Expr) → Lean.Expr.below proof → Lean.MetaM (Option Lean.Expr) | null | false |
Lean.Meta.ReduceMatcherResult.casesOn | Lean.Meta.WHNF | {motive : Lean.Meta.ReduceMatcherResult → Sort u} →
(t : Lean.Meta.ReduceMatcherResult) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.reduced val)) →
((val : Lean.Expr) → motive (Lean.Meta.ReduceMatcherResult.stuck val)) →
motive Lean.Meta.ReduceMatcherResult.notMatcher → motive Lean.... | null | false |
Std.Http.Internal.Char.isValidSchemeChar | Std.Http.Internal.Char | Char → Bool | Checks if a character is valid after the first character of a URI scheme.
Valid characters are ASCII alphanumeric, `+`, `-`, and `.`.
| true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.uncons? | Batteries.Data.MLList.Basic | {m : Type u → Type u} →
(self : MLList.Spec✝ m) → {α : Type u} → MLList.Spec.listM✝ self α → Option (Option (α × MLList.Spec.listM✝ self α)) | null | true |
OpenPartialHomeomorph.singletonChartedSpace._proof_2 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] {α : Type u_2} [inst_1 : TopologicalSpace α]
(e : OpenPartialHomeomorph α H), e ∈ {e} | null | false |
ContinuousCohomology.homogeneousCochains._proof_3 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | (ComplexShape.embeddingUp'Add 1 1).IsRelIff | null | false |
ChainComplex.mk'_congr_succ'_d._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(succ' : {X₀ X₁ : V} → (f : X₁ ⟶ X₀) → (X₂ : V) ×' (d : X₂ ⟶ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0)
{X Y : V} (f g : X ⟶ Y), f = g → (succ' f).fst = (succ' g).fst | null | false |
MeasureTheory.isTightMeasureSet_of_forall_basis_tendsto | Mathlib.MeasureTheory.Measure.TightNormed | ∀ {E : Type u_1} {mE : MeasurableSpace E} {S : Set (MeasureTheory.Measure E)} [inst : NormedAddCommGroup E]
{𝕜 : Type u_2} {ι : Type u_3} [inst_1 : RCLike 𝕜] [inst_2 : Fintype ι] [inst_3 : InnerProductSpace 𝕜 E]
[FiniteDimensional 𝕜 E] (b : OrthonormalBasis ι 𝕜 E),
(∀ (i : ι), Filter.Tendsto (fun r => ⨆ μ ∈ ... | null | true |
CategoryTheory.MorphismProperty.wrapped._@.Mathlib.CategoryTheory.Localization.LocallySmall.315190127._hygCtx._hyg.8 | Mathlib.CategoryTheory.Localization.LocallySmall | Subtype (Eq @CategoryTheory.MorphismProperty.definition✝) | null | false |
OpenPartialHomeomorph.coe_ofContinuousOpen | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialEquiv X Y)
(hc : ContinuousOn (↑e) e.source) (ho : IsOpenMap ↑e) (hs : IsOpen e.source),
↑(OpenPartialHomeomorph.ofContinuousOpen e hc ho hs) = ↑e | null | true |
Nat.strongRecOn'_beta | Mathlib.Data.Nat.Init | ∀ {motive : ℕ → Sort u_1} (ind : (n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) (t : ℕ),
Nat.strongRec ind t = ind t fun m x => Nat.strongRec ind m | **Alias** of `Nat.strongRec_eq`. | true |
_private.Plausible.Gen.0.Plausible.test | Plausible.Gen | ℕ → Plausible.Gen ℕ | null | true |
Lean.Meta.addToCompletionBlackList | Lean.Meta.CompletionName | Lean.Environment → Lean.Name → Lean.Environment | null | true |
_private.Mathlib.RingTheory.DedekindDomain.SelmerGroup.0.IsDedekindDomain.selmerGroup.fromUnit_ker._simp_1_1 | Mathlib.RingTheory.DedekindDomain.SelmerGroup | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
CategoryTheory.GradedObject.TriangleIndexData.p₂₃ | Mathlib.CategoryTheory.GradedObject.Unitor | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₃ : Type u_3} →
{J : Type u_4} →
[inst : Zero I₂] →
{r : I₁ × I₂ × I₃ → J} → {π : I₁ × I₃ → J} → CategoryTheory.GradedObject.TriangleIndexData r π → I₂ × I₃ → I₃ | a map `I₂ × I₃ → I₃` | true |
Order.sequenceOfCofinals.match_3 | Mathlib.Order.Ideal | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Filter.empty_notMem._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α) [f.NeBot], (∅ ∈ f) = False | null | false |
neg_iff_neg_of_smul_pos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : LinearOrder α] [inst_4 : LinearOrder β] [PosSMulMono α β] [SMulPosMono α β], 0 < a • b → (a < 0 ↔ b < 0) | null | true |
Lean.Elab.Command.mkInstanceName | Lean.Elab.DeclNameGen | Array Lean.Syntax → Lean.Syntax → Lean.Elab.Command.CommandElabM Lean.Name | Generates an instance name for a declaration that has the given binders and type.
It tries to make these names relatively unique ecosystem-wide.
Note that this elaborates the binders and the type.
This means that when elaborating an instance declaration, we elaborate these twice.
| true |
SimpleGraph.ConnectedComponent.reachable_toSimpleGraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent) {u v : V} (hu : u ∈ C) (hv : v ∈ C),
C.toSimpleGraph.Reachable ⟨u, hu⟩ ⟨v, hv⟩ | There is a walk between every pair of vertices in a connected component. | true |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.Scheme.Hom.map_resLE._simp_1_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {V V' : X.Opens} (i : V ≤ V'),
X.homOfLE i = AlgebraicGeometry.Scheme.Hom.resLE (CategoryTheory.CategoryStruct.id X) V' V i | null | false |
SeparationQuotient.instNonUnitalNonAssocCommSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocCommSemiring R] →
[IsTopologicalSemiring R] → NonUnitalNonAssocCommSemiring (SeparationQuotient R) | null | true |
Polynomial.roots_X_add_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (r : R), (Polynomial.X + Polynomial.C r).roots = {-r} | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._simp_1_4 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ (b : α), a ≤ b → b ∈ s | null | false |
MulSemiringAction.toAlgEquiv.congr_simp | Mathlib.FieldTheory.Galois.Basic | ∀ {G : Type u_2} (R : Type u_3) (A : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Group G] [inst_4 : MulSemiringAction G A] [inst_5 : SMulCommClass G R A] (g g_1 : G),
g = g_1 → MulSemiringAction.toAlgEquiv R A g = MulSemiringAction.toAlgEquiv R A g_1 | null | true |
GrpCat.recOn | Mathlib.Algebra.Category.Grp.Basic | {motive : GrpCat → Sort u_1} →
(t : GrpCat) → ((carrier : Type u) → [str : Group carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
CategoryTheory.Lax.StrongTrans.naturality_comp._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Lean.Syntax | null | false |
GroupNorm.coe_sup._simp_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] (p q : GroupNorm E), ⇑p ⊔ ⇑q = ⇑(p ⊔ q) | null | false |
HomotopicalAlgebra.FibrantBrownFactorization.ctorIdx | Mathlib.AlgebraicTopology.ModelCategory.BrownLemma | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : HomotopicalAlgebra.ModelCategory C} →
{X Y : C} → {f : X ⟶ Y} → HomotopicalAlgebra.FibrantBrownFactorization f → ℕ | null | false |
ULift.down_ratCast | Mathlib.Algebra.Field.ULift | ∀ {α : Type u} [inst : RatCast α] (q : ℚ), (↑q).down = ↑q | null | true |
Finset.smulCommClass | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : SMul α γ] [inst_2 : SMul β γ]
[SMulCommClass α β γ], SMulCommClass (Finset α) (Finset β) (Finset γ) | null | true |
Nat.div_le_div_right | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a ≤ b → a / c ≤ b / c | null | true |
RelIso.relEmbeddingCongr_symm_apply | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_5} {β₁ : Type u_6} {α₂ : Type u_7} {β₂ : Type u_8} {r₁ : α₁ → α₁ → Prop} {s₁ : β₁ → β₁ → Prop}
{r₂ : α₂ → α₂ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r r₂) (e₂ : s₁ ≃r s₂) (f₂ : r₂ ↪r s₂),
(e₁.relEmbeddingCongr e₂).symm f₂ = (e₁.toRelEmbedding.trans f₂).trans e₂.symm.toRelEmbedding | null | true |
AddConGen.Rel.below.rec | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {motive : (a a_1 : M) → AddConGen.Rel r a a_1 → Prop}
{motive_1 : {a a_1 : M} → (t : AddConGen.Rel r a a_1) → AddConGen.Rel.below t → Prop},
(∀ (x y : M) (a : r x y), motive_1 ⋯ ⋯) →
(∀ (x : M), motive_1 ⋯ ⋯) →
(∀ {x y : M} (a : AddConGen.Rel r x y) (ih :... | null | false |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs._sparseCasesOn_1 | Mathlib.Tactic.MoveAdd | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name... | null | false |
CategoryTheory.instComonadicLeftAdjointCoalgebraForget | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(G : CategoryTheory.Comonad C) → CategoryTheory.ComonadicLeftAdjoint G.forget | null | true |
Chebyshev.integral_theta_div_log_sq_isLittleO | Mathlib.NumberTheory.Chebyshev | (fun x => ∫ (t : ℝ) in 2..x, Chebyshev.theta t / (t * Real.log t ^ 2)) =o[Filter.atTop] fun x => x / Real.log x | null | true |
Nat.factorial_one | Mathlib.Data.Nat.Factorial.Basic | Nat.factorial 1 = 1 | null | true |
typeToPointed._proof_3 | Mathlib.CategoryTheory.Category.Pointed | ∀ (x : Type u_1),
Option.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id x))
{ X := Option x, point := none }.point =
Option.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id x))
{ X := Option x, point := none }.point | null | false |
Polynomial.toContinuousMapAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Polynomial | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [inst_2 : IsTopologicalSemiring R] (x : R),
((algebraMap R (Polynomial R)) x).toContinuousMap = (algebraMap R C(R, R)) x | null | false |
MeasureTheory.lintegral_sub_right_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : AddGroup G] [MeasurableAdd G]
[μ.IsAddRightInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (x - g) ∂μ = ∫⁻ (x : G), f x ∂μ | null | true |
Module.Basis.finTwoProd.eq_1 | Mathlib.LinearAlgebra.Basis.Fin | ∀ (R : Type u_7) [inst : Semiring R],
Module.Basis.finTwoProd R = Module.Basis.ofEquivFun (LinearEquiv.finTwoArrow R R).symm | null | true |
TopCat.Presheaf.isSheafOpensLeCover_iff_isSheafPairwiseIntersections | Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : TopCat} (F : TopCat.Presheaf C X),
F.IsSheafOpensLeCover ↔ F.IsSheafPairwiseIntersections | The sheaf condition
in terms of a limit diagram over all `{ V : Opens X // ∃ i, V ≤ U i }`
is equivalent to the reformulation
in terms of a limit diagram over `U i` and `U i ⊓ U j`.
| true |
Std.HashSet.Raw.mem_toList._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, (k ∈ m.toList) = (k ∈ m) | null | false |
WithTop.measurable_of_measurable_comp_coe | Mathlib.MeasureTheory.Constructions.BorelSpace.WithTop | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι]
[inst_3 : MeasurableSpace ι] [BorelSpace ι] {α : Type u_2} {mα : MeasurableSpace α} {f : WithTop ι → α},
(Measurable fun p => f ↑p) → Measurable f | null | true |
Cardinal.IsStrongLimit.casesOn | Mathlib.SetTheory.Cardinal.Order | {c : Cardinal.{u_1}} →
{motive : c.IsStrongLimit → Sort u} →
(t : c.IsStrongLimit) → ((ne_zero : c ≠ 0) → (isStrongPrelimit : c.IsStrongPrelimit) → motive ⋯) → motive t | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Ordering.swap.match_1.splitter | Std.Data.DTreeMap.Internal.Model | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.eq) → (Unit → motive Ordering.gt) → motive x | null | true |
Option.pfilter_filter | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : α → Bool} {q : (a : α) → Option.filter p o = some a → Bool},
(Option.filter p o).pfilter q = o.pfilter fun a h => if h' : p a = true then q a ⋯ else false | null | true |
AddSubgroup.comap_injective_isAddCommutative | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) {f : G' →+ G},
Function.Injective ⇑f → ∀ [IsAddCommutative ↥H], IsAddCommutative ↥(AddSubgroup.comap f H) | null | true |
Lean.Elab.Term.mkCalcFirstStepView | Lean.Elab.Calc | Lean.TSyntax `Lean.calcFirstStep → Lean.Elab.TermElabM Lean.Elab.Term.CalcStepView | null | true |
CategoryTheory.Limits.coprod.inr_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) {Z : C} (h : W ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.desc f... | null | true |
Lean.Meta.LazyDiscrTree.instEmptyCollectionTrie | Lean.Meta.LazyDiscrTree | {α : Type} → EmptyCollection (Lean.Meta.LazyDiscrTree.Trie α) | null | true |
Lean.Lsp.CompletionItemTag.deprecated.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemTag.deprecated = 1 | null | true |
LowerSet.mem_Iic_iff._simp_1 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ LowerSet.Iic a) = (b ≤ a) | null | false |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology.match_1 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} (c : Set (Set (Set X))) (motive : c.Nonempty → Prop) (x : c.Nonempty),
(∀ (hne : c.Nonempty) (x : Set (Set X)) (hxc : x ∈ c) (h : hne = ⋯), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Order.Field.Power.0.zpow_eq_neg_zpow_iff₀._simp_1_4 | Mathlib.Algebra.Order.Field.Power | ∀ (n : ℕ), Int.negSucc n = -↑n.succ | null | false |
tendsto_birkhoffAverage_apply_sub_birkhoffAverage' | Mathlib.Dynamics.BirkhoffSum.NormedSpace | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] (𝕜 : Type u_3) [inst_1 : RCLike 𝕜]
[inst_2 : NormedSpace 𝕜 E] {g : α → E},
Bornology.IsBounded (Set.range g) →
∀ (f : α → α) (x : α),
Filter.Tendsto (fun n => birkhoffAverage 𝕜 f g n (f x) - birkhoffAverage 𝕜 f g n x) Filter.atTop (nhds 0) | If a function `g` is bounded,
then the difference between Birkhoff averages of `g`
along the orbit of `f x` and along the orbit of `x`
tends to zero.
See also `tendsto_birkhoffAverage_apply_sub_birkhoffAverage`. | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.linearIndependent_unique_iff._simp_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Sort u_1} [inst : Unique α] {p : α → Prop}, (∀ (a : α), p a) = p default | null | false |
_private.Lean.SubExpr.0.Lean.Expr.traverseAppWithPos._sparseCasesOn_1 | Lean.SubExpr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
ZMod.differentiableAt_LFunction | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] (Φ : ZMod N → ℂ) (s : ℂ), s ≠ 1 ∨ ∑ j, Φ j = 0 → DifferentiableAt ℂ (ZMod.LFunction Φ) s | null | true |
EisensteinSeries.G2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | UpperHalfPlane → ℂ | The Eisenstein series of weight `2` and level `1` defined as the conditional sum
of `m` in `[N,N]` of `e2Summand m`. This sum over symmetric intervals is handy in showing it is
Summable. | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._proof_1_3 | Mathlib.Data.Int.Interval | ∀ (m n : ℕ) (a : ℤ), ¬(-(↑m + 1) ≤ a ∧ a < ↑n + 1 ↔ a = -(↑m + 1) ∨ a = ↑n ∨ -↑m ≤ a ∧ a < ↑n) → False | null | false |
WeierstrassCurve.Affine.baseChange_polynomialX | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [inst_1 : CommRing S] {A : Type u}
[inst_2 : CommRing A] {B : Type v} [inst_3 : CommRing B] [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScal... | null | true |
Subsemiring.comap_comap | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S]
[inst_2 : NonAssocSemiring T] (s : Subsemiring T) (g : S →+* T) (f : R →+* S),
Subsemiring.comap f (Subsemiring.comap g s) = Subsemiring.comap (g.comp f) s | null | true |
_private.Mathlib.Computability.Ackermann.0.ack.match_1.eq_1 | Mathlib.Computability.Ackermann | ∀ (motive : ℕ → ℕ → Sort u_1) (n : ℕ) (h_1 : (n : ℕ) → motive 0 n) (h_2 : (m : ℕ) → motive m.succ 0)
(h_3 : (m n : ℕ) → motive m.succ n.succ),
(match 0, n with
| 0, n => h_1 n
| m.succ, 0 => h_2 m
| m.succ, n.succ => h_3 m n) =
h_1 n | null | true |
lift_cardinalMk_eq_lift_cardinalMk_field_pow_lift_rank | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ (K : Type u) (V : Type v) [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V] [Module.Finite K V],
Cardinal.lift.{u, v} (Cardinal.mk V) = Cardinal.lift.{v, u} (Cardinal.mk K) ^ Cardinal.lift.{u, v} (Module.rank K V) | null | true |
MeasureTheory.locallyIntegrableOn_congr | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f g : X → ε} {μ : MeasureTheory.Measure X} {s : Set X},
f =ᵐ[μ.restrict s] g → (MeasureTheory.LocallyIntegrableOn f s μ ↔ MeasureTheory.LocallyIntegrableOn g s μ) | null | true |
Submodule.unitsToPic_apply | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) (A : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] (I : (Submodule R A)ˣ), (Submodule.unitsToPic R A) I = CommRing.Pic.mk R ↥↑I | null | true |
Nat.repr_of_ge | Init.Data.Nat.ToString | ∀ {n : ℕ}, 10 ≤ n → n.repr = (n / 10).repr ++ String.singleton (n % 10).digitChar | null | true |
CategoryTheory.Precoverage.Saturate.recOn | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} {X : C} {a : CategoryTheory.Sieve X}
(t : J.Saturate X a),
(∀ (X : C) (S : CategoryTheory.Presieve X) (hS : S ∈ J.coverings X), motive X (Cate... | null | false |
_private.Mathlib.Algebra.Polynomial.HasseDeriv.0.Polynomial.natDegree_hasseDeriv_le._simp_1_6 | Mathlib.Algebra.Polynomial.HasseDeriv | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) | null | false |
Int32.neg_mul_neg | Init.Data.SInt.Lemmas | ∀ (a b : Int32), -a * -b = a * b | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.recOn | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(t : Nat.NatOffset✝) →
((n : ℕ) → motive (Nat.NatOffset.const✝ n)) →
((e o : Lean.Expr) → (n : ℕ) → motive (Nat.NatOffset.offset✝ e o n)) → motive t | null | false |
StructureGroupoid.noConfusionType | Mathlib.Geometry.Manifold.StructureGroupoid | Sort u →
{H : Type u_2} →
[inst : TopologicalSpace H] →
StructureGroupoid H → {H' : Type u_2} → [inst' : TopologicalSpace H'] → StructureGroupoid H' → Sort u | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.mk._flat_ctor | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{F : CategoryTheory.Functor J C} →
{c : CategoryTheory.Limits.Cocone F} →
{X Y : C} →
{p : X ⟶ Y} →
{f : ... | null | false |
Std.Do.WP.withReader_MonadWithReader | Std.Do.WP.SimpLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ρ α : Type u} {Q : Std.Do.PostCond α ps} [inst : MonadWithReaderOf ρ m]
[inst_1 : Std.Do.WP m ps] (f : ρ → ρ) (x : m α),
(Std.Do.wp (withReader f x)).apply Q = (Std.Do.wp (MonadWithReaderOf.withReader f x)).apply Q | null | true |
lp.norm_zero | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)], ‖0‖ = 0 | null | true |
CategoryTheory.Abelian.SpectralObject.fromOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
(X : CategoryTheory.Abelian.SpectralObject C ι) →
{i j k : ι} →
(f : i ⟶ j) →
... | The map `H^n(f) ⟶ H^n(f ≫ g)` factors through `opZ^n(f, g)`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go_get_aux._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract | ∀ {newWidth : ℕ}, ∀ curr ≤ newWidth, ∀ idx < curr, idx < newWidth | null | false |
ContinuousLinearEquiv.ofFinrankEq._proof_2 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜], StrongRankCondition 𝕜 | null | false |
Matrix.instAddCommMagma | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [AddCommMagma α] → AddCommMagma (Matrix m n α) | null | true |
PositiveLinearMap.instModuleComplexPreGNS._aux_1 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} → [inst : NonUnitalCStarAlgebra A] → [inst_1 : PartialOrder A] → (f : A →ₚ[ℂ] ℂ) → SMul ℂ f.PreGNS | null | false |
Filter.Tendsto.eventually_intervalIntegrable_ae | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ι : Type u_1} {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E} {μ : MeasureTheory.Measure ℝ}
{l l' : Filter ℝ},
StronglyMeasurableAtFilter f l' μ →
∀ [Filter.TendstoIxxClass Set.Ioc l l'] [l'.IsMeasurablyGenerated],
μ.FiniteAtFilter l' →
∀ {c : E},
Filter.Tendsto f (l' ⊓ Measu... | Let `l'` be a measurably generated filter; let `l` be a of filter such that each `s ∈ l'`
eventually includes `Ioc u v` as both `u` and `v` tend to `l`. Let `μ` be a measure finite at `l'`.
Suppose that `f : ℝ → E` has a finite limit at `l' ⊓ ae μ`. Then `f` is interval integrable on
`u..v` provided that both `u` and ... | true |
_private.Lean.Meta.PProdN.0.Lean.Meta.PProdN.unpack.go._sparseCasesOn_1 | Lean.Meta.PProdN | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
SchwartzMap.compCLM_apply | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_2) {D : Type u_4} {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : RCLike 𝕜] [inst_5 : NormedAddCommGroup D]
[inst_6 : NormedSpace ℝ D] [inst_7 : NormedSpace 𝕜 F] {g : D → E} (hg : Function.Ha... | null | true |
Subsemigroup.recOn | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_3} →
[inst : Mul M] →
{motive : Subsemigroup M → Sort u} →
(t : Subsemigroup M) →
((carrier : Set M) →
(mul_mem' : ∀ {a b : M}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
motive { carrier := carrier, mul_mem' := mul_mem' }) →
motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.