name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Localization.SmallShiftedHom.mk | Mathlib.CategoryTheory.Localization.SmallShiftedHom | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
{M : Type w'} →
[inst_1 : AddMonoid M] →
[inst_2 : CategoryTheory.HasShift C M] →
{X Y : C} →
{m : M} →
[inst_3 : CategoryTheory.Localization.Ha... | Constructor for `SmallShiftedHom`. | true |
Lean.Meta.Grind.Arith.Linear.NatStruct.u | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.NatStruct → Lean.Level | Cached `getDecLevel type` | true |
Qq.Impl.withUnquotedLCtx | Qq.Macro | {m : Type → Type u_1} →
{α : Type} → [MonadControlT Lean.MetaM m] → [Monad m] → [MonadLiftT Qq.Impl.QuoteM m] → m α → m α | null | true |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.reportStuckSyntheticMVar.match_3 | Lean.Elab.SyntheticMVars | (motive : Option (Lean.MVarId → Lean.Expr → Lean.Expr → Lean.MetaM Lean.MessageData) → Sort u_1) →
(mkErrorMsg? : Option (Lean.MVarId → Lean.Expr → Lean.Expr → Lean.MetaM Lean.MessageData)) →
((mkErrorMsg : Lean.MVarId → Lean.Expr → Lean.Expr → Lean.MetaM Lean.MessageData) → motive (some mkErrorMsg)) →
((x ... | null | false |
Lean.Elab.Tactic.BVDecide.SolverMode.ctorElim | Std.Tactic.BVDecide.Syntax | {motive : Lean.Elab.Tactic.BVDecide.SolverMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.BVDecide.SolverMode) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.BVDecide.SolverMode.ctorElimType ctorIdx → motive t | null | false |
_private.Mathlib.RingTheory.Noetherian.Defs.0.isNoetherian_submodule.match_1_1 | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
(motive : IsNoetherian R ↥N → Prop) (x : IsNoetherian R ↥N),
(∀ (hn : ∀ (s : Submodule R ↥N), s.FG), motive ⋯) → motive x | null | false |
Std.IterM.Total.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Total | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM m β → Std.IterM.Total m β | null | false |
Lean.Meta.DefEqCache | Lean.Meta.Basic | Type | A mapping `(s, t) ↦ isDefEq s t`.
TODO: consider more efficient representations (e.g., a proper set) and caching policies (e.g., imperfect cache).
We should also investigate the impact on memory consumption.
| true |
CategoryTheory.RetractArrow.toLoc_id₁ | Mathlib.CategoryTheory.Bicategory.RetractArrow | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y X' Y' : C} {f' : X' ⟶ Y'} {f : X ⟶ Y}
(r : CategoryTheory.RetractArrow f' f), r.toLoc.id₁ = CategoryTheory.eqToIso ⋯ | null | true |
AlgebraicGeometry.IsImmersion.isLocallyClosed_range | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.IsImmersion f], IsLocallyClosed (Set.range ⇑f) | null | true |
OreLocalization.lift₂Expand.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_3}
[inst_2 : MulAction R X] {C : Sort u_2} (P : X → ↥S → X → ↥S → C)
(hP :
∀ (r₁ : X) (t₁ : R) (s₁ : ↥S) (ht₁ : t₁ * ↑s₁ ∈ S) (r₂ : X) (t₂ : R) (s₂ : ↥S) (ht₂ : t₂ * ↑s₂ ∈ S),
P r₁ s₁ r₂ s₂ = P (t₁ • r₁) ⟨... | null | true |
Int.sub_lt_sub_left | Init.Data.Int.Order | ∀ {a b : ℤ}, a < b → ∀ (c : ℤ), c - b < c - a | null | true |
CategoryTheory.ShortComplex.exact_map_iff_of_faithful | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {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.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (S : CategoryTheory.ShortComplex C) [S.HasHomology]
(F : CategoryTheory.Functor C D)... | null | true |
DifferentiableAt.comp_mdifferentiableWithinAt | Mathlib.Geometry.Manifold.MFDeriv.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 : NormedAddCommG... | null | true |
indicator_ae_eq_of_ae_eq_set | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α} {f : α → β}
[inst_1 : Zero β], s =ᵐ[μ] t → s.indicator f =ᵐ[μ] t.indicator f | null | true |
commMonTypeEquivalenceCommMon._proof_4 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (A : CommMonCat) (x x_1 : (CommMonTypeEquivalenceCommMon.inverse.obj A).X),
(Equiv.refl (CommMonTypeEquivalenceCommMon.inverse.obj A).X).toFun (x * x_1) =
(Equiv.refl (CommMonTypeEquivalenceCommMon.inverse.obj A).X).toFun (x * x_1) | null | false |
AffineSubspace.pointwise_vadd_direction | Mathlib.LinearAlgebra.AffineSpace.Pointwise | ∀ {k : Type u_2} {V : Type u_3} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (v : V) (s : AffineSubspace k P), (v +ᵥ s).direction = s.direction | null | true |
Lean.Meta.SimpEntry.toUnfold.sizeOf_spec | Lean.Meta.Tactic.Simp.SimpTheorems | ∀ (a : Lean.Name), sizeOf (Lean.Meta.SimpEntry.toUnfold a) = 1 + sizeOf a | null | true |
CategoryTheory.IsRegularMono | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Prop | `IsRegularMono f` is the assertion that `f` is a regular monomorphism. | true |
PUnit.mulSemiringAction._proof_2 | Mathlib.Algebra.Module.PUnit | ∀ {R : Type u_2} [inst : Semiring R] (r : R) (x y : PUnit.{u_1 + 1}), r • (x * y) = r • x * r • y | null | false |
Mathlib.Tactic.Order.Graph.TarjanState | Mathlib.Tactic.Order.Graph.Tarjan | Type | State for Tarjan's algorithm. | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZeta.0.HurwitzZeta.sinZeta_eq._simp_1_2 | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.Compiler.CSimp.State.mk.injEq | Lean.Compiler.CSimpAttr | ∀ (map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) (thmNames : Lean.SSet Lean.Name)
(map_1 : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) (thmNames_1 : Lean.SSet Lean.Name),
({ map := map, thmNames := thmNames } = { map := map_1, thmNames := thmNames_1 }) =
(map = map_1 ∧ thmNames = thmNames_1) | null | true |
Lean.Elab.Term.ElabElim.State.mk._flat_ctor | Lean.Elab.App | Lean.Expr →
Lean.Expr →
List Lean.Elab.Term.NamedArg →
List Lean.Elab.Term.Arg → Array Lean.MVarId → ℕ → Option Lean.Expr → Lean.Elab.Term.ElabElim.State | null | false |
Std.DHashMap.getD.congr_simp | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (m m_1 : Std.DHashMap α β),
m = m_1 → ∀ (a : α) (fallback fallback_1 : β a), fallback = fallback_1 → m.getD a fallback = m_1.getD a fallback_1 | null | true |
NeZero.one_le | Mathlib.Data.Nat.Cast.NeZero | ∀ {n : ℕ} [NeZero n], 1 ≤ n | null | true |
GroupTopology.instCompleteLattice._proof_8 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] (s : Set (GroupTopology α)), IsGLB s (sInf s) | null | false |
SubgroupClass.instZPow.eq_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {M : Type u_5} {S : Type u_6} [inst : DivInvMonoid M] [inst_1 : SetLike S M] [inst_2 : SubgroupClass S M] {H : S},
SubgroupClass.instZPow = { pow := fun a n => ⟨↑a ^ n, ⋯⟩ } | null | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.mk.noConfusion | Lean.Compiler.LCNF.ExplicitRC | {P : Sort u} →
{parents : Array Lean.FVarId} →
{children : Lean.FVarIdHashSet} →
{parents' : Array Lean.FVarId} →
{children' : Lean.FVarIdHashSet} →
{ parents := parents, children := children } = { parents := parents', children := children' } →
(parents = parents' → children = ... | null | false |
CategoryTheory.IsIso.eq_inv_comp | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ⟶ Y) [inst_1 : CategoryTheory.IsIso α]
{f : X ⟶ Z} {g : Y ⟶ Z},
g = CategoryTheory.CategoryStruct.comp (CategoryTheory.inv α) f ↔ CategoryTheory.CategoryStruct.comp α g = f | null | true |
CategoryTheory.Precoverage.mk | Mathlib.CategoryTheory.Sites.Precoverage | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
((X : C) → Set (CategoryTheory.Presieve X)) → CategoryTheory.Precoverage C | null | true |
Lean.Compiler.LCNF.LetValue.updateArgs! | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu | null | true |
PadicInt.coe_neg | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (z1 : ℤ_[p]), ↑(-z1) = -↑z1 | null | true |
Homeomorph.locallyConnectedSpace | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [i : LocallyConnectedSpace Y]
(h : X ≃ₜ Y), LocallyConnectedSpace X | If the codomain of a homeomorphism is a locally connected space, then the domain is also
a locally connected space. | true |
Lean.Elab.Term.Do.Code.jmp | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Name → Array Lean.Syntax → Lean.Elab.Term.Do.Code | null | true |
FormalMultilinearSeries.id_apply_zero | Mathlib.Analysis.Analytic.Composition | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (x : E) (v : Fin 0 → E), (FormalMultilinearSeries.id 𝕜 E x 0) v = x | null | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor_const._simp_1_5 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
LieSubalgebra.root._proof_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_1} [inst : Field K], IsDomain K | null | false |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.wSameSide_affineSpan_faceOpposite_point_left_iff._simp_1_3 | Mathlib.Analysis.Convex.Side | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
Topology.IsInducing.hasSum_iff | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} [inst_2 : AddCommMonoid γ] [inst_3 : TopologicalSpace γ] {G : Type u_4}
[inst_4 : FunLike G α γ] [AddMonoidHomClass G α γ] {g : G},
Topology.IsInducing ⇑g → ∀ (f : β → α) (a : α), HasSum (... | null | true |
OrderDual.instCancelCommMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CancelCommMonoid α],
OrderDual.instCancelCommMonoid = { toCommMonoid := OrderDual.instCommMonoid, toIsLeftCancelMul := ⋯ } | null | true |
_private.Init.Data.Vector.InsertIdx.0.Vector.getElem_insertIdx_of_gt._proof_1 | Init.Data.Vector.InsertIdx | ∀ {n i k : ℕ}, k ≤ n → k > i → ¬i ≤ n → False | null | false |
CategoryTheory.Join.mkNatIso._proof_1 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] {E : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} E]
{F G : CategoryTheory.Functor (CategoryTheory.Join C D) E}
(eₗ : (CategoryTheory.Join.inclLeft C D).comp F ≅ (CategoryTheory.... | null | false |
CategoryTheory.Equalizer.Sieve.firstMap | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))) →
{X : C} →
(S : CategoryTheory.Sieve X) →
CategoryTheory.Equalizer.FirstObj P S.arrows ⟶ CategoryTheory.Equalizer.Sieve.SecondObj P S | The map `p` of Equations (3,4) [MM92]. | true |
Filter.atBot_countable_basis | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u_1} [inst : Preorder α] [IsCodirectedOrder α] [Nonempty α] [Countable α],
Filter.atBot.HasCountableBasis (fun x => True) Set.Iic | null | true |
Lean.ParserCompiler.Context.rec | Lean.ParserCompiler | {α : Type} →
{motive : Lean.ParserCompiler.Context α → Sort u} →
((varName : Lean.Name) →
(categoryAttr : Lean.KeyedDeclsAttribute α) →
(combinatorAttr : Lean.ParserCompiler.CombinatorAttribute) →
motive { varName := varName, categoryAttr := categoryAttr, combinatorAttr := combinator... | null | false |
CategoryTheory.IsAddMonHom.Normal.isAddMonHom | Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.CartesianMonoidalCategory C}
{G H : C} {inst_2 : CategoryTheory.AddGrpObj G} {inst_3 : CategoryTheory.AddGrpObj H} {φ : H ⟶ G}
[self : CategoryTheory.IsAddMonHom.Normal φ], CategoryTheory.IsAddMonHom φ | null | true |
Filter.subseq_tendsto_of_neBot | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u_1} {f : Filter α} [f.IsCountablyGenerated] {u : ℕ → α},
(f ⊓ Filter.map u Filter.atTop).NeBot → ∃ θ, StrictMono θ ∧ Filter.Tendsto (u ∘ θ) Filter.atTop f | null | true |
Std.DTreeMap.Internal.Impl.getKeyGT.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α) (size : ℕ) (ky : α) (y : β ky)
(l r : Std.DTreeMap.Internal.Impl α β) (ho : (Std.DTreeMap.Internal.Impl.inner size ky y l r).Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.inner size ky y l r, compare a k = Ordering.gt),
Std.DTreeMa... | null | true |
CategoryTheory.Limits.isBilimitOfTotal._proof_2 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_3}
[inst_2 : Fintype J] {f : J → C} (b : CategoryTheory.Limits.Bicone f),
∑ j, CategoryTheory.CategoryStruct.comp (b.π j) (b.ι j) = CategoryTheory.CategoryStruct.id b.pt →
∀ (s : CategoryTheory.Lim... | null | false |
RingCon.instNonAssocSemiringQuotient._proof_4 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R),
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Matrix.smul_eq_diagonal_mul | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype m]
[inst_2 : DecidableEq m] (M : Matrix m n α) (a : α), a • M = (Matrix.diagonal fun x => a) * M | null | true |
ContinuousLinearMap.uncurryBilinear._proof_9 | Mathlib.Analysis.Analytic.Linear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], IsNormableSpace 𝕜 F | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.head._proof_1 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {a : ℕ} {L : List ℕ}, 0 < (a :: L).length | null | false |
Complex.nnnorm_intCast | Mathlib.Analysis.Complex.Basic | ∀ (n : ℤ), ‖↑n‖₊ = ‖n‖₊ | null | true |
MeasureTheory.hahn_decomposition | Mathlib.MeasureTheory.Measure.Decomposition.Hahn | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν],
∃ s,
MeasurableSet s ∧
(∀ (t : Set α), MeasurableSet t → t ⊆ s → ν t ≤ μ t) ∧ ∀ (t : Set α), MeasurableSet t → t ⊆ sᶜ → μ t ≤ ν t | **Hahn decomposition theorem** | true |
HasDerivAt.cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {f : ℝ → ℝ} {f' x : ℝ}, HasDerivAt f f' x → HasDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x | null | true |
Lean.Declaration.getNames | Lean.Declaration | Lean.Declaration → List Lean.Name | Returns all names to be defined by adding this declaration to the environment. This does not include
auxiliary definitions such as projections added by the elaborator, nor auxiliary recursors computed
by the kernel for nested inductive types.
| true |
CategoryTheory.Limits.inv_prodComparison_map_snd | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.ProdComparison | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {A B : C} [inst_2 : CategoryTheory.Limits.HasBinaryProduct A B]
[inst_3 : CategoryTheory.Limits.HasBinaryProduct (F.obj A) (F.obj B)]
[inst_4 : CategoryTheory.IsIso... | null | true |
padicValInt.eq_zero_of_not_dvd | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} {z : ℤ}, ¬↑p ∣ z → padicValInt p z = 0 | null | true |
ENat.toNat_zero | Mathlib.Data.ENat.Basic | ENat.toNat 0 = 0 | null | true |
SeparationQuotient.continuousOn_lift._simp_1 | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y}
{hf : ∀ (x y : X), Inseparable x y → f x = f y} {s : Set (SeparationQuotient X)},
ContinuousOn (SeparationQuotient.lift f hf) s = ContinuousOn f (SeparationQuotient.mk ⁻¹' s) | null | false |
compactumToCompHaus.isoOfTopologicalSpace._proof_6 | Mathlib.Topology.Category.Compactum | ∀ {D : CompHaus}, T2Space (Compactum.ofTopologicalSpace ↑D.toTop).A | null | false |
wrapped._@.Mathlib.MeasureTheory.Integral.CurveIntegral.Basic.4195796962._hygCtx._hyg.2 | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | Subtype (Eq @definition✝) | null | false |
Std.TreeMap.Raw.getKey_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
(h₁ : t₁.WF) (h₂ : t₂.WF) {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).getKey k h' = t₂.getKey k ⋯ | null | true |
Nat.toList_rcc_eq_cons_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : List ℕ} {m n a : ℕ}, (m...=n).toList = a :: xs ↔ m = a ∧ m ≤ n ∧ (m + 1...=n).toList = xs | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.mk.noConfusion | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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.MonoidalCategory C} →
{P : Sort u} →
{toMonoidalRightActionStruct : CategoryTheory.MonoidalCategory.MonoidalRightActionSt... | null | false |
_private.Mathlib.NumberTheory.FLT.Four.0.Fermat42.not_minimal._proof_1_7 | Mathlib.NumberTheory.FLT.Four | ∀ {a : ℤ},
a % 2 = 1 → ∀ (m r s : ℤ), a = r ^ 2 - s ^ 2 → m = r ^ 2 + s ^ 2 → ∀ (k : ℤ), s = k ^ 2 ∨ s = -k ^ 2 → s ^ 2 = k ^ 4 | null | false |
Lean.Lsp.instToJsonLeanModule.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.LeanModule → Lean.Json | null | true |
LocallyConnectedSpace.open_connected_basis | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u_3} {inst : TopologicalSpace α} [self : LocallyConnectedSpace α] (x : α),
(nhds x).HasBasis (fun s => IsOpen s ∧ x ∈ s ∧ IsConnected s) id | Open connected neighborhoods form a basis of the neighborhoods filter. | true |
LinearEquiv.toSpanNonzeroSingleton._proof_3 | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) [inst : Ring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
ENNReal.toNNReal_toReal_eq | Mathlib.Basic.ENNReal.Basic | ∀ (z : ENNReal), z.toReal.toNNReal = z.toNNReal | null | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ioc_erase_right._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
TypeVec.toSubtype'._proof_3 | Mathlib.Data.TypeVec | ∀ (n : ℕ) (α : TypeVec.{u_1} (n + 1)) (p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop))
(x : (fun i => { x // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.1 x.2)) }) Fin2.fz),
TypeVec.ofRepeat (p Fin2.fz (TypeVec.prod.mk Fin2.fz (↑x).1 (↑x).2)) = p Fin2.fz ↑x | null | false |
CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.instRingEmbeddingRing._proof_45 | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_1} [inst_1 : CategoryTheory.SmallCategory D]
(F : CategoryTheory.Functor D Cᵒᵖ) [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.IsGrothendieckAbelian.{u_1, u_1, u_2} C],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupW... | null | false |
AlgebraicGeometry.Scheme.GlueData.ι_isoLocallyRingedSpace_inv | Mathlib.AlgebraicGeometry.Gluing | ∀ (D : AlgebraicGeometry.Scheme.GlueData) (i : D.J),
CategoryTheory.CategoryStruct.comp (D.toLocallyRingedSpaceGlueData.ι i) D.isoLocallyRingedSpace.inv =
AlgebraicGeometry.Scheme.Hom.toLRSHom (D.ι i) | null | true |
_private.Mathlib.Analysis.Matrix.Order.0.Matrix.PosSemidef.matrixPreInnerProductSpace._proof_1 | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_2} {n : Type u_1} [inst : RCLike 𝕜] [inst_1 : Fintype n] {M : Matrix n n 𝕜},
M.PosSemidef →
∀ (x x_1 : Matrix n n 𝕜), (starRingEnd 𝕜) (x * M * x_1.conjTranspose).trace = (x_1 * M * x.conjTranspose).trace | null | false |
Polynomial.toContinuousMapOnAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Polynomial | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [inst_2 : IsTopologicalSemiring R] (X : Set R)
(x : R), ((algebraMap R (Polynomial R)) x).toContinuousMapOn X = (algebraMap R C(↑X, R)) x | null | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.escape | Lean.DocString.Markdown | String → String | Backslash-escapes Markdown-significant punctuation in `s` so it renders as literal text. `s` must
be a single line.
| true |
_private.Lean.Elab.Do.PatternVar.0.Lean.Elab.Do.getExprPatternVarsEx.match_1 | Lean.Elab.Do.PatternVar | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(var? : Option (Lean.TSyntax `ident)) →
((var : Lean.TSyntax `ident) → motive (some var)) → (Unit → motive none) → motive var? | null | false |
PointedCone.Face.instSemilatticeInf._proof_2 | Mathlib.Geometry.Convex.Cone.Face.Lattice | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C : PointedCone R M} (x x_1 : C.Face), ∀ x_2 ∈ x ⊓ x_1, x_2 ∈ ↑↑x_1 | null | false |
CategoryTheory.IsSplitCoequalizer.map._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z}
(q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D),
CategoryTheory.CategoryStruct.comp (F.map q.rightSection) (F.map... | null | false |
Std.DTreeMap.Internal.Impl.minEntry?.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} (x : Std.DTreeMap.Internal.Impl α β),
x.minEntry? =
match x with
| Std.DTreeMap.Internal.Impl.leaf => none
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r => some ⟨k, v⟩
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Interna... | null | true |
Nat.zeckendorf.eq_2 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.succ.zeckendorf = n.succ.greatestFib :: (n.succ - Nat.fib n.succ.greatestFib).zeckendorf | null | true |
MonoidHom.ergodic_of_dense_iUnion_preimage_one | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [SecondCountableTopology G]
[inst_4 : MeasurableSpace G] [BorelSpace G] [CompactSpace G] {μ : MeasureTheory.Measure G} [μ.IsHaarMeasure]
(f : G →* G), Dense (⋃ n, (⇑f)^[n] ⁻¹' 1) → Continuous ⇑f → Function.Surjective ⇑f → Ergodic... | Let `f : G →* G` be a continuous surjective group endomorphism
of a compact topological group with second countable topology.
If the preimages of `1` under the iterations of `f` are dense,
then `f` is ergodic with respect to any finite inner regular left invariant measure. | true |
Ideal.mulQuot._proof_2 | Mathlib.RingTheory.OrderOfVanishing.Basic | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
ContDiffMapSupportedIn.withSeminorms' | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] (n : ℕ∞) (K : TopologicalSpace.Compacts E),
WithSemi... | null | true |
Std.DHashMap.Raw.Const.alter.congr_simp | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] [inst_2 : Hashable α] {β : Type v}
(m m_1 : Std.DHashMap.Raw α fun x => β),
m = m_1 →
∀ (a a_1 : α),
a = a_1 →
∀ (f f_1 : Option β → Option β),
f = f_1 → Std.DHashMap.Raw.Const.alter m a f = Std.DHashMap.Raw.Const.alter m_1 a_1 f_1 | null | true |
AlgebraicGeometry.LocallyRingedSpace.Γ_def | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | AlgebraicGeometry.LocallyRingedSpace.Γ =
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.op.comp AlgebraicGeometry.SheafedSpace.Γ | null | true |
WeierstrassCurve.Affine.baseChange_a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve.Affine R) (S : Type s) [inst_1 : CommRing S]
[inst_2 : Algebra R S], (W.baseChange S).a₂ = (algebraMap R S) W.a₂ | null | true |
SFinKer.instMonoidalCategory._proof_11 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y Z : SFinKer),
ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.deterministic ⇑MeasurableEquiv.prodAssoc ⋯) | null | false |
CategoryTheory.Lax.LaxTrans.noConfusionType | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Sort u →
{B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
CategoryTheory.Lax.LaxTrans F G →
{B' : Type u₁} →
[inst' : CategoryTheory.Bicategory B... | null | false |
CategoryTheory.IsSplitEqualizer.casesOn | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f g : X ⟶ Y} →
{W : C} →
{ι : W ⟶ X} →
{motive : CategoryTheory.IsSplitEqualizer f g ι → Sort u_1} →
(t : CategoryTheory.IsSplitEqualizer f g ι) →
((leftRetraction : X ⟶ W) →
... | null | false |
Lean.Loop._sizeOf_1 | Init.While | Lean.Loop → ℕ | null | false |
CategoryTheory.CatEnriched.instBicategory._proof_4 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c : CategoryTheory.CatEnriched C}
(f : a ⟶ b) {g h i : b ⟶ c} (η : g ⟶ h) (θ : h ⟶ i),
CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruc... | null | false |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.card_support_eq_one._simp_1_2 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α},
(f.support = {a}) = (f a ≠ 0 ∧ f = fun₀ | a => f a) | null | false |
Inclusion.IntervalBool.undetermined.elim | Mathlib.Tactic.Inclusion.Core.ToSet | {motive : Inclusion.IntervalBool → Sort u} →
(t : Inclusion.IntervalBool) → t.ctorIdx = 2 → motive Inclusion.IntervalBool.undetermined → motive t | null | false |
_private.Lean.Compiler.LCNF.ToImpureType.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.ToImpureType.1487298532._hygCtx._hyg.2 | Lean.Compiler.LCNF.ToImpureType | IO (Lean.MapDeclarationExtension (Option Lean.Compiler.LCNF.TrivialStructureInfo)) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_alter_eq_self_of_mem._simp_1_1 | 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 |
Std.ExtTreeMap.getKeyD_insertIfNew | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k a fallback : α} {v : β},
(t.insertIfNew k v).getKeyD a fallback = if cmp k a = Ordering.eq ∧ k ∉ t then k else t.getKeyD a fallback | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.