name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Internal.Raw₀.get!_alter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {k k' : α},
(↑m).WF →
∀ [inst_3 : Inhabited (β k')] {f : Option (β k) → Option (β k)},
(m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast ⋯) (f (m.get? k))... | null | true |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_hom | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α β : X ⟶ Y) (h : α = β) (x : ↑↑X),
AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (AlgebraicGe... | null | true |
MulAlgebraNorm.noConfusionType | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | Sort u →
{R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
MulAlgebraNorm R S →
{R' : Type u_1} →
[inst' : SeminormedCommRing R'] →
{S' : Type u_2} → [inst'_1 : Ring S']... | null | false |
Lean.Meta.MVarRenaming.noConfusionType | Lean.Meta.Match.MVarRenaming | Sort u → Lean.Meta.MVarRenaming → Lean.Meta.MVarRenaming → Sort u | null | false |
Absorbs.sInter | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α] {t : Set α}
{S : Set (Set α)}, S.Finite → (∀ s ∈ S, Absorbs G₀ s t) → Absorbs G₀ (⋂₀ S) t | **Alias** of the reverse direction of `Set.Finite.absorbs_sInter`. | true |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_1 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (h : α × β), (∀ (a : α) (b : β), motive (a, b)) → motive h | null | false |
CategoryTheory.MonoOver.imageForgetAdj._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : CategoryTheory.Over X) (g : CategoryTheory.MonoOver X) (k : f ⟶ (CategoryTheory.MonoOver.forget X).obj g),
(fun k =>
CategoryTheory.Over.homMk
(CategoryTheory.CategoryStruct.com... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.termS | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | Lean.ParserDescr | null | true |
Nat.instTransLe | Init.Data.Nat.Basic | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | null | true |
AddActionHom.prodMap._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_5} {N : Type u_6} {α : Type u_1} {β : Type u_2} {γ : Type u_4} {δ : Type u_3} [inst : VAdd M α]
[inst_1 : VAdd M β] [inst_2 : VAdd N γ] [inst_3 : VAdd N δ] {σ : M → N} (f : α →ₑ[σ] γ) (g : β →ₑ[σ] δ) (m : M)
(x : α × β),
((f.comp (AddActionHom.fst M α β)).prod (g.comp (AddActionHom.snd M α β))).toFu... | null | false |
SchwartzMap.fderivCLM._proof_7 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (F : Type u_1) [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
Lean.DefinitionVal.getSafetyEx | Lean.Declaration | Lean.DefinitionVal → Lean.DefinitionSafety | null | true |
CategoryTheory.Functor.WellOrderInductionData.ofExists._proof_4 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_2)}
(h₁ :
∀ (j : J),
¬IsMax j → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.homOfLE ⋯).op)))
(j : J) (hj : ¬IsMax j) (x : F.obj (Opposite.op j)),
(CategoryTheory.Co... | null | false |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPattern.parenthesizer_127 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
Aesop.EqualUpToIdsM.run' | Aesop.Util.EqualUpToIds | {α : Type} →
Aesop.EqualUpToIdsM α →
Option Lean.MetavarContext →
Lean.MetavarContext → Lean.MetavarContext → Bool → Lean.MetaM (α × Aesop.EqualUpToIdsM.State) | null | true |
Lean.isIdRestAscii | Init.Meta.Defs | UInt8 → Bool | null | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ici_erase._simp_1_4 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
Topology.ContinuousMapGeneratedBy.curryEquiv._proof_6 | Mathlib.Topology.Convenient.HomSpace | ∀ {ι : Type u_4} {X : ι → Type u_5} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type u_1}
[inst_1 : TopologicalSpace Y] {Z : Type u_2} [inst_2 : TopologicalSpace Z] {T : Type u_3}
[inst_3 : TopologicalSpace T] [inst_4 : ∀ (i : ι), LocallyCompactSpace (X i)]
[inst_5 : ∀ (i j : ι), Topology.IsGeneratedBy X (X i ... | null | false |
CategoryTheory.Limits.isBilimitOfIsLimit._proof_1 | 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} (t : CategoryTheory.Limits.Bicone f) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (∑ j, CategoryTheory.CategoryStruct.comp (t.π j) (t.ι j)) (t... | null | false |
Nat.Prime.mem_primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {n p : ℕ}, Nat.Prime p → p ∣ n → n ≠ 0 → p ∈ n.primeFactors | null | true |
Lean.Grind.CommRing.Poly.combine.go.eq_5 | Init.Grind.Ring.CommSolver | ∀ (fuel_2 : ℕ) (k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁_2 : Lean.Grind.CommRing.Poly) (k₂ : ℤ)
(m₂ : Lean.Grind.CommRing.Mon) (p₂_2 : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.combine.go fuel_2.succ (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁_2)
(Lean.Grind.CommRing.Poly.add k₂ m₂ p₂_2) =
match m₁... | null | true |
Int32.maxValue_le_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {a : Int32}, (Int32.maxValue ≤ a) = (a = Int32.maxValue) | null | false |
trapezoidal_integral | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ | Integration of `f` from `a` to `b` using the trapezoidal rule with `N+1` total evaluations of
`f`. (Note the off-by-one problem here: `N` counts the number of trapezoids, not the number of
evaluations.) | true |
Orientation.kahler_rotation_left' | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (θ : Real.Angle),
(o.kahler ((o.rotation θ) x)) y = ↑(-θ).toCircle * (o.kahler x) y | Rotating the first of two vectors by `θ` scales their Kähler form by `cos (-θ) + sin (-θ) * I`.
| true |
Filter.Germ.instAddAction._proof_2 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M β] (f : α → β),
0 +ᵥ ↑f = ↑f | null | false |
RingHom.FinitePresentation.comp_surjective | Mathlib.RingTheory.FinitePresentation | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{f : A →+* B} {g : B →+* C},
f.FinitePresentation → Function.Surjective ⇑g → (RingHom.ker g).FG → (g.comp f).FinitePresentation | null | true |
CategoryTheory.WithTerminal.coneEquiv._proof_5 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y),
CategoryTheory.CategoryS... | null | false |
commutatorElement_def | Mathlib.Algebra.Group.Commutator | ∀ {G : Type u_1} [inst : Group G] (g₁ g₂ : G), ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹ | null | true |
SubgroupClass.inclusion_self | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G]
[inst_3 : Preorder S] [inst_4 : IsConcreteLE S G] (x : ↥H), (SubgroupClass.inclusion ⋯) x = x | null | true |
Congruent.index_equiv._simp_1 | Mathlib.Topology.MetricSpace.Congruence | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} [inst : PseudoEMetricSpace P₁]
[inst_1 : PseudoEMetricSpace P₂] {E : Type u_7} [inst_2 : EquivLike E ι' ι] (f : E) (v₁ : ι → P₁) (v₂ : ι → P₂),
Congruent (v₁ ∘ ⇑f) (v₂ ∘ ⇑f) = Congruent v₁ v₂ | null | false |
Polynomial.leadingCoeff_X_pow_sub_one | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Ring R] {n : ℕ}, 0 < n → (Polynomial.X ^ n - 1).leadingCoeff = 1 | null | true |
IsGreatest.nnnorm_cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Monotone.of_left_le_map_sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup α] [inst_1 : Preorder β] {f : α → β},
(∀ (x y : α), f x ≤ f (x ⊔ y)) → Monotone f | null | true |
diagonal_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NonUnitalNonAssocSemiring α]
(v w : m → α) (i : m), Matrix.diagonal v i ⬝ᵥ w = v i * w i | null | true |
Aesop.NormRuleResult.proved.injEq | Aesop.Search.Expansion.Norm | ∀ (steps? steps?_1 : Option (Array Aesop.Script.LazyStep)),
(Aesop.NormRuleResult.proved steps? = Aesop.NormRuleResult.proved steps?_1) = (steps? = steps?_1) | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.commandExpandersForUnsafe | Lean.Elab.DocString | Lean.Ident →
Lean.Elab.TermElabM
(Array
(Lean.Name ×
StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))) | null | true |
Matroid.IsBasis.isBasis_isRestriction | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α} {N : Matroid α},
M.IsBasis I X → N.IsRestriction M → X ⊆ N.E → N.IsBasis I X | null | true |
CategoryTheory.ShortComplex.descRightHomology | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
{A : C} →
(k : S.X₂ ⟶ A) →
CategoryTheory.CategoryStruct.comp S.f k = 0 → [inst_2 : S.HasRightHomology] → S.rightHomology... | The morphism `S.rightHomology ⟶ A` obtained from a morphism `k : S.X₂ ⟶ A`
such that `S.f ≫ k = 0.` | true |
Lean.Meta.SolveByElim.SolveByElimConfig.testPartialSolutions | Lean.Meta.Tactic.SolveByElim | optParam Lean.Meta.SolveByElim.SolveByElimConfig { } →
(List Lean.Expr → Lean.MetaM Bool) → Lean.Meta.SolveByElim.SolveByElimConfig | Create or modify a `Config` which rejects branches for which `test`,
applied to the instantiations of the original goals, fails or returns `false`.
| true |
CategoryTheory.Limits.Types.limitConeIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J (Type (max u_3 u_2)))
(s : CategoryTheory.Limits.Cone F) (j : J),
CategoryTheory.CategoryStruct.comp
(TypeCat.ofHom fun v => ⟨fun j => (CategoryTheory.ConcreteCategory.hom (s.π.app j)) v, ⋯⟩)
((CategoryTheory.Li... | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.unsat_of_encounteredBoth._proof_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} (assignment : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(if (!l.2) = true then Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit l
else Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty) =
Std.... | null | false |
CategoryTheory.Functor.sheafPushforwardContinuousComp' | Mathlib.CategoryTheory.Sites.Continuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D E} →
... | When we have an isomorphism `F ⋙ G ≅ FG` between continuous functors
between sites, the composition of the pushforward functors for
`G` and `F` identifies to the pushforward functor for `FG`. | true |
Array.merge.go._unsafe_rec | Batteries.Data.Array.Merge | {α : Type u_1} → (α → α → Bool) → Array α → Array α → Array α → ℕ → ℕ → Array α | null | false |
CategoryTheory.LaxMonoidalFunctor.laxMonoidal._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.size_union_of_not_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α},
(k ∉ m) = (m.contains k = false) | null | false |
Con.ker_rel._simp_2 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) {x y : M}, (Con.ker f) x y = (f x = f y) | null | false |
_private.Lean.Elab.ConfigEval.Instances.0.Lean.Elab.ConfigEval.EvalTerm.evalOptionStx.match_1 | Lean.Elab.ConfigEval.Instances | {α : Type} →
(motive : α × Lean.Expr → Sort u_1) → (x : α × Lean.Expr) → ((v : α) → (e : Lean.Expr) → motive (v, e)) → motive x | null | false |
BitVec.toInt_sub_of_not_ssubOverflow | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, ¬x.ssubOverflow y = true → (x - y).toInt = x.toInt - y.toInt | null | true |
_private.Mathlib.Analysis.Analytic.Inverse.0.FormalMultilinearSeries.rightInv_removeZero.match_1_1 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E)
(motive : (n : ℕ) → (∀ m < n, p.removeZero.right... | null | false |
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit t → (s.pt ≅ t.... | Limits of `F` are unique up to isomorphism. | true |
List.range'_eq_singleton_iff._simp_1 | Init.Data.List.Nat.Range | ∀ {s n a : ℕ}, (List.range' s n = [a]) = (s = a ∧ n = 1) | null | false |
CommBialgCat.isoEquivBialgEquiv._proof_1 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : CommRing X] [inst_2 : Bialgebra R X]
[inst_3 : CommRing Y] [inst_4 : Bialgebra R Y] (x : CommBialgCat.of R X ≅ CommBialgCat.of R Y),
CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) = CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) | null | false |
AddEquiv.ext_int_iff | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f = g ↔ f 1 = g 1 | null | true |
logDeriv.eq_1 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] (f : 𝕜 → 𝕜'), logDeriv f = deriv f / f | null | true |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.definition._simp_5._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.1878421158._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Cardinal.ofENat_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {x : Cardinal.{v}} {m : ℕ∞}, (↑m ≤ Cardinal.lift.{u, v} x) = (↑m ≤ x) | null | false |
List.minOn_eq_min | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : LE α] [DecidableLE α] [Std.LawfulOrderLeftLeaningMin α]
[inst_4 : LE β] [inst_5 : DecidableLE β] {f : α → β} {l : List α} {h : l ≠ []},
(∀ (a b : α), f a ≤ f b ↔ a ≤ b) → List.minOn f l h = l.min h | null | true |
Lean.Server.FileWorker.SignatureHelp.CandidateKind.toCtorIdx | Lean.Server.FileWorker.SignatureHelp | Lean.Server.FileWorker.SignatureHelp.CandidateKind → ℕ | null | false |
CategoryTheory.EffectiveEquivalenceRelation.noConfusion | Mathlib.CategoryTheory.EquivalenceRelation | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{R A : C} →
{p₁ p₂ : R ⟶ A} →
{t : CategoryTheory.EffectiveEquivalenceRelation p₁ p₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} C'} →
{R' A' : C'}... | null | false |
nhds_subtype_eq_comap | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop} {x : X} {h : p x},
nhds ⟨x, h⟩ = Filter.comap Subtype.val (nhds x) | null | true |
lt_of_lt_add_of_nonpos_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightMono α] {a b c : α}, a < b + c → b ≤ 0 → a < c | null | true |
closureAddCommutatorRepresentatives.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G],
closureAddCommutatorRepresentatives G =
AddSubgroup.closure (Prod.fst '' addCommutatorRepresentatives G ∪ Prod.snd '' addCommutatorRepresentatives G) | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
ContinuousLinearMap.instMeasurableSpace._proof_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | null | false |
_private.Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup.0.Algebra.GrothendieckGroup.of_injective._simp_1_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (x : M), (Localization.monoidOf S) x = Localization.mk x 1 | null | false |
Path.trans_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X} (γ : Path x y) (γ' : Path y z) (t : ↑unitInterval),
(γ.trans γ') t = if h : ↑t ≤ 1 / 2 then γ ⟨2 * ↑t, ⋯⟩ else γ' ⟨2 * ↑t - 1, ⋯⟩ | null | true |
HomologicalComplex.restrictionMap_id | Mathlib.Algebra.Homology.Embedding.Restriction | ∀ {ι : 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.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff],
HomologicalComplex.restrictionMap (CategoryTheory.... | null | true |
Lean.Meta.AbstractNestedProofs.isNonTrivialProof | Lean.Meta.AbstractNestedProofs | Lean.Expr → Lean.MetaM Bool | null | true |
strictConcaveOn_of_slope_strict_anti_adjacent | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
Convex 𝕜 s →
(∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)) →
StrictConcaveOn 𝕜 s f | If for any three points `x < y < z`, the slope of the secant line of `f : 𝕜 → 𝕜` on `[x, y]` is
strictly greater than the slope of the secant line of `f` on `[y, z]`, then `f` is strictly concave.
| true |
mfderivWithin_prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
CategoryTheory.Pseudofunctor.DescentData.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
(obj : (i : ι) → ↑(F.obj { as := Opposite.op (X... | null | false |
ModularForm.sub_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f g : ModularForm Γ k) (z : UpperHalfPlane), (f - g) z = f z - g z | null | true |
RelSeries.head_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).head = f p.head | null | true |
_private.Lean.Meta.Offset.0.Lean.Meta.evalNat._sparseCasesOn_2 | Lean.Meta.Offset | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Server.Completion.HoverInfo.noConfusionType | Lean.Server.Completion.CompletionUtils | Sort u → Lean.Server.Completion.HoverInfo → Lean.Server.Completion.HoverInfo → Sort u | null | false |
Lean.Meta.DiscrTree.Trie.ctorIdx | Lean.Meta.DiscrTree.Types | {α : Type} → Lean.Meta.DiscrTree.Trie α → ℕ | null | false |
IsAddUnit.addUnit_add | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a b : M} (ha : IsAddUnit a) (hb : IsAddUnit b),
⋯.addUnit = ha.addUnit + hb.addUnit | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Signature.0.QuadraticForm.posDef_spanSubset._simp_1_5 | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
MonoidHom.finsuppProd_apply | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_7} {N : Type u_10} {P : Type u_11} [inst : Zero β] [inst_1 : MulOneClass N]
[inst_2 : CommMonoid P] (f : α →₀ β) (g : α → β → N →* P) (x : N), (f.prod g) x = f.prod fun i fi => (g i fi) x | null | true |
CategoryTheory.Limits.Types.Small.productLimitCone | Mathlib.CategoryTheory.Limits.Types.Products | {J : Type v} → (F : J → Type u) → [Small.{u, v} J] → CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor F) | A variant of `productLimitCone` using a `Small` hypothesis rather than a function to `Type`.
| true |
Std.Do.SPred.entails.refl._simp_1 | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} (P : Std.Do.SPred σs), (P ⊢ₛ P) = True | null | false |
UniformSpace.Completion.instAddMonoid._proof_12 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (n : ℕ)
(a : UniformSpace.Completion α), (n + 1) • a = n • a + a | null | false |
abs_pow_eq_one | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {n : ℕ} (a : α),
n ≠ 0 → (|a ^ n| = 1 ↔ |a| = 1) | null | true |
Pi.uniformSpace.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)],
Pi.uniformSpace α =
UniformSpace.ofCoreEq (⨅ i, UniformSpace.comap (Function.eval i) (U i)).toCore Pi.topologicalSpace ⋯ | null | true |
Aesop.RappId.instLT | Aesop.Tree.Data | LT Aesop.RappId | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
(motive : aig.ArbitraryShiftTarget w → Sort u_1) →
(target : aig.ArbitraryShiftTarget w) →
((n : ℕ) →
(input : aig.RefVec w) →
(di... | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.Tendsto.isLindelof_insert_range_of_coLindelof._simp_1_3 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty = ¬Disjoint s t | null | false |
IsLocalRing.ResidueField.map_id_apply | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] (x : IsLocalRing.ResidueField R),
(IsLocalRing.ResidueField.map (RingHom.id R)) x = x | null | true |
DomMulAct.instLeftCancelMonoidOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [LeftCancelMonoid Mᵐᵒᵖ] → LeftCancelMonoid Mᵈᵐᵃ | null | true |
Equiv.Perm.subtypeEquivSubtypePerm_apply_of_not_mem | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {p : α → Prop} [inst : DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)),
¬p a → ↑((Equiv.Perm.subtypeEquivSubtypePerm p) f) a = a | null | true |
String.Slice.Pattern.Model.CharPred.instPatternModelForallCharBool | Init.Data.String.Lemmas.Pattern.Pred | {p : Char → Bool} → String.Slice.Pattern.Model.PatternModel p | null | true |
mem_absConvexHull_iff | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E} {x : E}, x ∈ (absConvexHull 𝕜) s ↔ ∀ (t : Set E), s ⊆ t → AbsConvex 𝕜 t → x ∈ t | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.getConstTemp?._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 6 t.ctorIdx → motive t) → motive t | null | false |
Finsupp.sumFinsuppLEquivProdFinsupp_symm_inr | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_7}
{β : Type u_8} (fg : (α →₀ M) × (β →₀ M)) (y : β),
((Finsupp.sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y | null | true |
Polynomial.eval₂_finset_sum | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} {ι : Type y} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (s : Finset ι)
(g : ι → Polynomial R) (x : S), Polynomial.eval₂ f x (∑ i ∈ s, g i) = ∑ i ∈ s, Polynomial.eval₂ f x (g i) | **Alias** of `Polynomial.eval₂_finsetSum`. | true |
Aesop.ForwardHypData | Aesop.RuleTac.Forward.Basic | Type | null | true |
CategoryTheory.Equivalence.toAdjunction_unit | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.toAdjunction.unit = e.unit | null | true |
CoeT.mk.noConfusion | Init.Coe | {α : Sort u} →
{x : α} → {β : Sort v} → {P : Sort u_1} → {coe coe' : β} → { coe := coe } = { coe := coe' } → (coe ≍ coe' → P) → P | null | false |
Lean.MetavarContext.MkBinding.Context.noConfusionType | Lean.MetavarContext | Sort u → Lean.MetavarContext.MkBinding.Context → Lean.MetavarContext.MkBinding.Context → Sort u | null | false |
WeierstrassCurve.Jacobian.addZ_self | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R), WeierstrassCurve.Jacobian.addZ P P = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.