name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Iterate.0.String.Slice.RevByteIterator.instIteratorUInt8OfPure._simp_5 | Init.Data.String.Iterate | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | false |
HasFiniteFPowerSeriesOnBall.fderiv_eq | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {r : ENNReal} {n : ℕ} {f : E → F} {x : E},
HasFiniteFPowerSeriesOnBall f p x ... | true |
Std.Http.Extensions | Std.Internal.Http.Data.Extensions | Type | true |
CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts_functor | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type (u₁ + 1)} [inst : CategoryTheory.LargeCategory C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C],
(CategoryTheory.Mat_.equivalenceSelfOfHasFiniteBiproducts C).functor =
CategoryTheory.Mat_.lift (CategoryTheory.Functor.id C) | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.NormalExpr) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(α : Mathlib.Tactic.BicategoryLike.Structural) → motive (Mathlib.Tactic.BicategoryLike.NormalExpr.nil e α)) →
((e : Mathlib.Tactic.BicategoryLik... | false |
Lean.Elab.Term.Do.Code.below_4 | Lean.Elab.Do.Legacy | {motive_1 : Lean.Elab.Term.Do.Code → Sort u} →
{motive_2 : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_3 : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code) → Sort u} →
{motive_4 : List (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code) → Sort u} →
{motive_5 : List (L... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.not_hasNeg_removeNeg._proof_1_1 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ (assignment : Std.Tactic.BVDecide.LRAT.Internal.Assignment), ¬assignment.removeNegAssignment.hasNegAssignment = true | false |
ArchimedeanClass.FiniteResidueField.instField._proof_10 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
autoParam
(∀ (x : ArchimedeanClass.FiniteResidueField K), ArchimedeanClass.FiniteResidueField.instField._aux_8 0 x = 0)
AddMonoid.nsmul_zero._autoParam | false |
FiniteGaloisIntermediateField.finGaloisGroup | Mathlib.FieldTheory.Galois.Profinite | {k : Type u_1} →
{K : Type u_2} →
[inst : Field k] → [inst_1 : Field K] → [inst_2 : Algebra k K] → FiniteGaloisIntermediateField k K → FiniteGrp.{u_2} | true |
LinearMap.domRestrict'._proof_3 | Mathlib.Algebra.Module.Submodule.LinearMap | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M] [inst_4 : Module R M₂] (p : Submodule R M) (m : R) (x : M →ₗ[R] M₂),
(m • x).domRestrict p = (RingHom.id R) m • x.domRestrict p | false |
HomologicalComplex.extendMap_zero | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K L : HomologicalComplex C c) (e : c.Embedding c'),
HomologicalComplex.ext... | true |
Lean.instInhabitedStructureParentInfo.default | Lean.Structure | Lean.StructureParentInfo | true |
CovByVAdd.rfl | Mathlib.Combinatorics.Additive.CovBySMul | ∀ {M : Type u_1} {X : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M X] {A : Set X}, CovByVAdd M 1 A A | true |
List.SortedLT.strictMono | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {n : ℕ} {f : Fin n → α}, (List.ofFn f).SortedLT → StrictMono f | true |
nnnorm_abs_zsmul | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (a : E) (n : ℤ), ‖|n| • a‖₊ = ‖n • a‖₊ | true |
Lean.Syntax.Range.recOn | Lean.Syntax | {motive : Lean.Syntax.Range → Sort u} →
(t : Lean.Syntax.Range) → ((start stop : String.Pos.Raw) → motive { start := start, stop := stop }) → motive t | false |
WithBot.preimage_coe_Ioc_bot | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some ⁻¹' Set.Ioc ⊥ ↑a = Set.Iic a | true |
Lean.mkIntEq | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | true |
Int.sign_eq_tdiv_abs | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ), a.sign = a.tdiv ↑a.natAbs | true |
LinearIsometryEquiv.toAffineIsometryEquiv | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_5} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : SeminormedAddCommGroup V₂] → [inst_4 : NormedSpace 𝕜 V₂] → (V ≃ₗᵢ[𝕜] V₂) → V ≃ᵃⁱ[𝕜] V₂ | true |
ENNReal.log_pow | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ {x : ENNReal} {n : ℕ}, (x ^ n).log = ↑n * x.log | true |
GenLoop.boundary | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} (f : ↑(GenLoop N X x)),
∀ y ∈ Cube.boundary N, f y = x | true |
AnalyticOnNhd.comp_sub | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : 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] {f : E → F} {s : Set E},
AnalyticOnNhd 𝕜 f s → ∀ (y : E), AnalyticOnNhd 𝕜 (fun z => f (z - y)) (s + {y}) | true |
Lean.Expr.quickLt | Lean.Expr | Lean.Expr → Lean.Expr → Bool | true |
Abelianization.lift | Mathlib.GroupTheory.Abelianization.Defs | {G : Type u} → [inst : Group G] → {A : Type v} → [inst_1 : CommGroup A] → (G →* A) ≃ (Abelianization G →* A) | true |
CategoryTheory.Limits.Cofork.IsColimit.π_desc'_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {s : CategoryTheory.Limits.Cofork f g}
(hs : CategoryTheory.Limits.IsColimit s) {W : C} (k : Y ⟶ W)
(h : CategoryTheory.CategoryStruct.comp f k = CategoryTheory.CategoryStruct.comp g k) {Z : C} (h_1 : W ⟶ Z),
CategoryTheory.CategoryS... | true |
Valuation.IsUniformizer.val_pos | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {A : Type u_2} [inst_1 : Ring A] {v : Valuation A Γ}
[hv : v.IsRankOneDiscrete] {π : A}, v.IsUniformizer π → 0 < v π | true |
PartialEquiv.trans_ofSet | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (s : Set β), e.trans (PartialEquiv.ofSet s) = e.restr (↑e ⁻¹' s) | true |
AlgebraicGeometry.StructureSheaf.sectionsSubalgebra._proof_2 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] (U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (y : ↥U),
1 ∉ (↑y).asIdeal | false |
Countable.rec | Mathlib.Data.Countable.Defs | {α : Sort u} →
{motive : Countable α → Sort u_1} →
((exists_injective_nat' : ∃ f, Function.Injective f) → motive ⋯) → (t : Countable α) → motive t | false |
CategoryTheory.Limits.CoconeMorphism.map_w_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{c c' : CategoryTheory.Limits.Cone F} (f : c ⟶ c') (G : CategoryTheory.Functor C D) (j : J) {Z : D}
(... | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_umod_of_le_of_ne_zero_of_le._simp_1_4 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (¬x < y) = (y ≤ x) | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_suffix.elim | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.AC.DiseqCnstrProof) →
t.ctorIdx = 5 →
((lhs : Bool) →
(s : Lean.Grind.AC.Seq) →
(c₁ : Lean.Meta.Grind.AC.EqCnstr) →
(c₂ : Lean.Meta.Grind.AC.DiseqCnstr) →
motive_2 (Lean.Meta.G... | false |
CategoryTheory.Abelian.functorCategoryAbelian | Mathlib.CategoryTheory.Abelian.FunctorCategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type w} →
[inst_1 : CategoryTheory.Category.{z, w} D] →
[CategoryTheory.Abelian D] → CategoryTheory.Abelian (CategoryTheory.Functor C D) | true |
DirichletCharacter.LFunctionTrivChar₁_apply_one_ne_zero | Mathlib.NumberTheory.LSeries.DirichletContinuation | ∀ (n : ℕ) [inst : NeZero n], DirichletCharacter.LFunctionTrivChar₁ n 1 ≠ 0 | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_3.eq_4 | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → Sort u_1) (id₁ : ℕ) (rhs : Lean.Expr)
(rhsTerms : Lean.Meta.Grind.SolverTerms) (id₂ : ℕ) (lhs : Lean.Expr) (lhsTerms : Lean.Meta.Grind.SolverTerms)
(h_1 : Unit → motive Lean.Meta.Grind.SolverTerms.nil Lean.Meta.Grind.SolverTerms.nil)
(h_2 :
... | true |
Aesop.option._@.Aesop.Check.611402289._hygCtx._hyg.3 | Aesop.Check | Lean.Option Bool | false |
AddGrpCat.FilteredColimits.G.mk_eq | Mathlib.Algebra.Category.Grp.FilteredColimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J AddGrpCat) (x y : (j : J) × ↑(F.obj j)),
(∃ k f g,
(CategoryTheory.ConcreteCategory.hom (F.map f)) x.snd = (CategoryTheory.ConcreteCategory.hom (F.map g)) y.snd) →
AddGrpCat.Filtered... | true |
Mathlib.Tactic.CategoryTheory.CancelIso.hom_inv_id_of_eq._to_dual_1 | Mathlib.Tactic.CategoryTheory.CancelIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {x y : C} (f : y ⟶ x) [inst_1 : CategoryTheory.IsIso f]
(g : x ⟶ y), CategoryTheory.inv f = g → CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.id x | false |
_private.Mathlib.RingTheory.HahnSeries.Addition.0.HahnSeries.addOppositeEquiv_orderTop._simp_1_2 | Mathlib.RingTheory.HahnSeries.Addition | ∀ {Γ : Type u_1} {R : Type u_2} {inst : PartialOrder Γ} {inst_1 : Zero R} {x y : HahnSeries Γ R},
(x = y) = (x.coeff = y.coeff) | false |
_private.Mathlib.LinearAlgebra.QuadraticForm.Prod.0.QuadraticMap.posDef_pi_iff._simp_1_1 | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {M : Type u_4} {N : Type u_5} {R₂ : Type u} [inst : CommSemiring R₂] [inst_1 : AddCommMonoid M] [inst_2 : Module R₂ M]
[inst_3 : PartialOrder N] [inst_4 : AddCommMonoid N] [inst_5 : Module R₂ N] {Q : QuadraticMap R₂ M N},
Q.PosDef = ((∀ (x : M), 0 ≤ Q x) ∧ Q.Anisotropic) | false |
Finset.addCommMonoid.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddCommMonoid α],
Finset.addCommMonoid = Function.Injective.addCommMonoid SetLike.coe ⋯ ⋯ ⋯ ⋯ | true |
Representation.IntertwiningMap.coe_neg | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} [inst : Semiring A] [inst_1 : Monoid G] {V : Type u_6} {W : Type u_7}
[inst_2 : AddCommMonoid V] [inst_3 : AddCommGroup W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (f : ρ.IntertwiningMap σ), ⇑(-f) = -⇑f | true |
Matrix.toMvPolynomial_one | Mathlib.Algebra.Module.LinearMap.Polynomial | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : CommSemiring R] [inst_2 : DecidableEq n],
Matrix.toMvPolynomial 1 = MvPolynomial.X | true |
optionProdEquiv_symm_inr | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} {β : Type u_10} (p : α × β), optionProdEquiv.symm (Sum.inr p) = Prod.map some id p | true |
SubMulAction.ofFixingSubgroup_of_inclusion_injective | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s t : Set α} {hst : t ⊆ s},
Function.Injective ⇑(SubMulAction.ofFixingSubgroup_of_inclusion M hst) | true |
instRingUniversalEnvelopingAlgebra._aux_20 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → One (UniversalEnvelopingAlgebra R L) | false |
Int.instMin | Init.Data.Int.Basic | Min ℤ | true |
Mathlib.Tactic.Ring.ExBase.evalNatCast | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
(sβ : Q(CommSemiring «$β»)) →
{a : Q(ℕ)} →
Mathlib.Tactic.Ring.ExBase sβ a →
Mathlib.Tactic.AtomM (Mathlib.Tactic.Ring.Common.Result (Mathlib.Ta... | true |
CategoryTheory.MonoidalCategory.InducedLawfulDayConvolutionMonoidalCategoryStructCore.mkLawfulDayConvolutionMonoidalCategoryStruct | Mathlib.CategoryTheory.Monoidal.DayConvolution | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(V : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
(D : Type u₃) →
[inst_4 : CategoryTheory.Cat... | true |
CategoryTheory.Limits.preservesCofilteredLimitsOfSize_shrink | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{max w w₂, max w' w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{w, w', v... | true |
Lean.Lsp.instToJsonDocumentSymbolParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.DocumentSymbolParams | true |
DifferentiableOn.div_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {s : Set 𝕜} {𝕜' : Type u_2} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'},
DifferentiableOn 𝕜 c s → ∀ (d : 𝕜'), DifferentiableOn 𝕜 (fun x => c x / d) s | true |
Nat.stirlingSecond | Mathlib.Combinatorics.Enumerative.Stirling | ℕ → ℕ → ℕ | true |
Std.DTreeMap.toList.eq_1 | Std.Data.TreeMap.Iterator | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap α β cmp), t.toList = t.inner.toList | true |
_private.Init.Data.Int.LemmasAux.0.Int.neg_lt_self_iff._proof_1_1 | Init.Data.Int.LemmasAux | ∀ {n : ℤ}, ¬(-n < n ↔ 0 < n) → False | false |
_private.Mathlib.Lean.Meta.0.Lean.MVarId.existsi.match_1 | Mathlib.Lean.Meta | (motive : List Lean.MVarId → Sort u_1) →
(subgoals : List Lean.MVarId) →
((sg1 sg2 : Lean.MVarId) → motive [sg1, sg2]) → ((x : List Lean.MVarId) → motive x) → motive subgoals | false |
Finsupp.Colex.partialOrder._proof_4 | Mathlib.Data.Finsupp.Lex | ∀ {α : Type u_2} {N : Type u_1} [inst : Zero N] [inst_1 : LinearOrder α] [inst_2 : PartialOrder N]
(a b : Colex (α →₀ N)), a ≤ b → b ≤ a → a = b | false |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.Sentence.realize_cardGe._simp_1_8 | Mathlib.ModelTheory.Semantics | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
frontier_Ioc | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[NoMaxOrder α] {a b : α}, a < b → frontier (Set.Ioc a b) = {a, b} | true |
intervalIntegral.integral_hasDerivWithinAt_of_tendsto_ae_left | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E} {c : E}
{a b : ℝ},
IntervalIntegrable f MeasureTheory.volume a b →
∀ {s t : Set ℝ} [intervalIntegral.FTCFilter a (nhdsWithin a s) (nhdsWithin a t)],
StronglyMeasurableAtFilter f (nhdsWithin a t) Measure... | true |
inv_mem_iff | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {S : Type u_3} {G : Type u_4} [inst : InvolutiveInv G] {x : SetLike S G} [InvMemClass S G] {H : S} {x_1 : G},
x_1⁻¹ ∈ H ↔ x_1 ∈ H | true |
isLocalHomeomorph_iff_isOpenEmbedding_restrict | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f ↔ ∀ (x : X), ∃ U ∈ nhds x, Topology.IsOpenEmbedding (U.restrict f) | true |
Int.Linear.Expr.denote.eq_3 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (a : Int.Linear.Expr), Int.Linear.Expr.denote ctx a.neg = -Int.Linear.Expr.denote ctx a | true |
ChartedSpaceCore.openPartialHomeomorph._proof_2 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] (c : ChartedSpaceCore H M), ∀ e ∈ c.atlas, IsOpen e.target | false |
Aesop.instInhabitedGoalStats.default | Aesop.Stats.Basic | Aesop.GoalStats | true |
WeierstrassCurve | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | Type u → Type u | true |
ContDiffBump.instInhabited._proof_1 | Mathlib.Analysis.Calculus.BumpFunction.Basic | (1 + 1).AtLeastTwo | false |
SeparationQuotient.edist_mk | Mathlib.Topology.EMetricSpace.Basic | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (x y : X),
edist (SeparationQuotient.mk x) (SeparationQuotient.mk y) = edist x y | true |
circleIntegral.integral_undef | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {c : ℂ} {R : ℝ},
¬CircleIntegrable f c R → ∮ (z : ℂ) in C(c, R), f z = 0 | true |
AntitoneOn.map_isLeast | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {t : Set α} {a : α},
AntitoneOn f t → IsLeast t a → IsGreatest (f '' t) (f a) | true |
_private.Mathlib.Data.Multiset.Defs.0.Multiset.decidableEqPiMultiset._simp_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
NonUnitalStarSubalgebra.instIsScalarTower' | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R' : Type u'} {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) [inst_4 : Semiring R'] [inst_5 : SMul R' R]
[inst_6 : Module R' A] [inst_7 : IsScalarTower R' R A], IsScalarTower R' R ↥S | true |
CategoryTheory.FreeBicategory | Mathlib.CategoryTheory.Bicategory.Free | Type u → Type u | true |
_private.Mathlib.Analysis.Convex.Continuous.0.ConvexOn.isBoundedUnder_abs._simp_1_1 | Mathlib.Analysis.Convex.Continuous | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {P : β → Prop},
(∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) | false |
Finsupp.degree_zero | Mathlib.Data.Finsupp.Weight | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Zero M] [inst_1 : Zero N] [inst_2 : FunLike F M N]
[ZeroHomClass F M N] (f : F), f 0 = 0 | true |
Polynomial.quotientSpanXSubCAlgEquiv._proof_6 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (x : R), (RingHom.ker (Polynomial.evalRingHom x)).IsTwoSided | false |
Std.Internal.List.Const.getKey_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : EquivBEq α] {k k' : α} {f : β → β} (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
∀ (h : Std.Internal.List.containsKey k' (Std.Internal.List.Const.modifyKey k f l) = true),
Std.Internal.List.getKey k' (Std.Internal.List.Const.modifyKey k f l... | true |
CategoryTheory.NatTrans.Coequifibered_of_isIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] {F G : CategoryTheory.Functor J C} (α : F ⟶ G)
[CategoryTheory.IsIso α], CategoryTheory.NatTrans.Coequifibered α | true |
_private.Lean.Class.0.Lean.initFn._@.Lean.Class.1274053790._hygCtx._hyg.2 | Lean.Class | IO Unit | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.isBase_compl_iff_maximal_disjoint_isBase._simp_1_8 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {s t u : Set α}, (s ⊆ t \ u) = (s ⊆ t ∧ Disjoint s u) | false |
_private.Init.Data.String.Lemmas.Pattern.Split.Basic.0.String.Slice.Pattern.Model.splitFromSteps.eq_def | Init.Data.String.Lemmas.Pattern.Split.Basic | ∀ {s : String.Slice} (currPos : s.Pos) (l : List (String.Slice.Pattern.SearchStep s)),
String.Slice.Pattern.Model.splitFromSteps✝ currPos l =
match l with
| [] => [s.subsliceFrom currPos]
| String.Slice.Pattern.SearchStep.rejected startPos endPos :: l =>
String.Slice.Pattern.Model.splitFromSteps✝ cu... | true |
instSubColex.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : Sub α], instSubColex = h | true |
OrElse.rec | Init.Prelude | {α : Type u} →
{motive : OrElse α → Sort u_1} →
((orElse : α → (Unit → α) → α) → motive { orElse := orElse }) → (t : OrElse α) → motive t | false |
Fin.ofNat_add | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] (x : ℕ) (y : Fin n), Fin.ofNat n x + y = Fin.ofNat n (x + ↑y) | true |
Finset.disjoint_empty_left | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} (s : Finset α), Disjoint ∅ s | true |
CategoryTheory.Mon.mkIso'.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (e : M ≅ N)
[inst_4 : CategoryTheory.IsMonHom e.hom],
CategoryTheory.Mon.mkIso' e =
{ hom := { hom := e.hom, isMonHom_hom := ... | true |
Fin.addRothNumber_eq_rothNumberNat | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {k n : ℕ}, 2 * k ≤ n → addRothNumber (Finset.Iio ↑k) = rothNumberNat k | true |
MeasureTheory.rnDeriv_ae_eq_condExp | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {hm : m ≤ m0}
[hμm : MeasureTheory.SigmaFinite (μ.trim hm)] {f : α → ℝ},
MeasureTheory.Integrable f μ →
MeasureTheory.SignedMeasure.rnDeriv ((μ.withDensityᵥ f).trim hm) (μ.trim hm) =ᵐ[μ] μ[f | m] | true |
Lean.Meta.RefinedDiscrTree.Key.proj.injEq | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ (typeName : Lean.Name) (idx nargs : ℕ) (typeName_1 : Lean.Name) (idx_1 nargs_1 : ℕ),
(Lean.Meta.RefinedDiscrTree.Key.proj typeName idx nargs =
Lean.Meta.RefinedDiscrTree.Key.proj typeName_1 idx_1 nargs_1) =
(typeName = typeName_1 ∧ idx = idx_1 ∧ nargs = nargs_1) | true |
Mathlib.Tactic.Ring.Common.evalMulProd._unsafe_rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute bt sα →
Mathlib.Tactic.Ring.Common.RingCompute Mathlib.Tactic.Ring.Common.btℕ Mathlib.Tactic.Ring.Common.sℕ →
{a b : Q(«$α»)} →
Mathli... | false |
PSet.mem_toSet | Mathlib.SetTheory.ZFC.PSet | ∀ (a u : PSet.{u}), a ∈ u.toSet ↔ a ∈ u | true |
SeminormedRing.induced._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ (R : Type u_1) [inst : Ring R] (n : ℕ) (x : R), Semiring.npow (n + 1) x = Semiring.npow n x * x | false |
Real.sinh_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {x : ℝ}, 1 ≤ x → Real.sinh (Real.arcosh x) = √(x ^ 2 - 1) | true |
_private.Lean.Elab.DocString.0.Lean.Doc.instTypeNameElabImage | Lean.Elab.DocString | TypeName Lean.Doc.ElabImage✝ | true |
AddGroupSeminorm.add_le' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} [inst : AddGroup G] (self : AddGroupSeminorm G) (r s : G),
self.toFun (r + s) ≤ self.toFun r + self.toFun s | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.standardσ_simplicialInsert._proof_1_10 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (m₁ : ℕ) (L : List ℕ) {m : ℕ}, m + L.length + 2 = m₁ → m + 1 + 1 + L.length = m₁ | false |
Std.TreeMap.getD_diff_of_not_mem_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : β}, k ∉ t₁ → (t₁ \ t₂).getD k fallback = fallback | true |
IsCyclotomicExtension.Rat.ramificationIdxIn_of_prime | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p} ℚ K], (Ideal.span {↑p}).ramificationIdxIn (NumberField.RingOfIntegers K) = p - 1 | true |
_private.Mathlib.Data.Setoid.Partition.Card.0.Setoid.IsPartition.ncard_eq_finsum._simp_1_11 | Mathlib.Data.Setoid.Partition.Card | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.