name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicGeometry.Scheme.height_of_isClosed | Mathlib.AlgebraicGeometry.Scheme | ∀ {X : AlgebraicGeometry.Scheme} {x : ↥X}, IsClosed {x} → Order.height x = 0 | null | true |
Std.DHashMap.Internal.Raw₀.forall_mem_keys_iff_forall_contains_getKey | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {p : α → Prop}, (∀ k ∈ (↑m).keys, p k) ↔ ∀ (k : α) (h : m.contains k = true), p (m.getKey k h) | null | true |
_private.Std.Http.Data.Headers.Name.0.Std.Http.Header.Name.transferEncoding._proof_1 | Std.Http.Data.Headers.Name | Std.Http.Header.IsValidHeaderName "transfer-encoding" | null | false |
Fin.Icc_sub_one_eq_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} {a b : Fin n}, 0 < b → Finset.Icc a (b - 1) = Finset.Ico a b | null | true |
ZFSet.mem_prod._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {x y z : ZFSet.{u}}, (z ∈ x.prod y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b | null | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizeImpl | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → optParam (Option Lean.Expr) none → Lean.Meta.Grind.GoalM Unit | null | true |
Int.sub_max_sub_left | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), max (a - b) (a - c) = a - min b c | null | true |
Set.div_empty | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Div α] {s : Set α}, s / ∅ = ∅ | null | true |
finsum_mem_image' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {s : Set β} {g : β → α},
Set.InjOn g (s ∩ Function.support (f ∘ g)) → ∑ᶠ (i : α) (_ : i ∈ g '' s), f i = ∑ᶠ (j : β) (_ : j ∈ s), f (g j) | The sum of `f y` over `y ∈ g '' s` equals the sum of `f (g i)` over `s` provided that
`g` is injective on `s ∩ support (f ∘ g)`. | true |
ContMDiffVAdd | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
ModelWithCorners 𝕜 E H →
{H' : Type u_4} →
... | Basic typeclass stating that the additive action of `G` on `M` is Cⁿ as a function `G × M → M`.
Unlike with `ContMDiffAdd` (the class stating that addition `G × G → G` within a single type `G` is
Cⁿ), we do not extend `IsManifold` because `ContMDiffVAdd` contains more
explicit arguments than `IsManifold` and so `ContMD... | true |
ContinuousMultilinearMap.ofSubsingleton._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ (R : Type u_4) {ι : Type u_3} (M₂ : Type u_1) (M₃ : Type u_2) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] (f : ContinuousMultilinearMap R (fun x => M₂) M₃), Continuous (⇑f ∘ ... | null | false |
_private.Mathlib.Algebra.CharZero.Defs.0.charZero_of_inj_zero._simp_1_1 | Mathlib.Algebra.CharZero.Defs | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) | null | false |
OrderDual.instNonAssocSemiring._proof_4 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonAssocSemiring R],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
ContinuousAddEquiv.trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_1} →
{N : Type u_2} →
[inst : TopologicalSpace M] →
[inst_1 : TopologicalSpace N] →
[inst_2 : Add M] →
[inst_3 : Add N] →
{L : Type u_3} → [inst_4 : Add L] → [inst_5 : TopologicalSpace L] → M ≃ₜ+ N → N ≃ₜ+ L → M ≃ₜ+ L | The composition of two ContinuousAddEquiv. | true |
GroupTopology.casesOn | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} →
[inst : Group α] →
{motive : GroupTopology α → Sort u_1} →
(t : GroupTopology α) →
((toTopologicalSpace : TopologicalSpace α) →
(toIsTopologicalGroup : IsTopologicalGroup α) →
motive { toTopologicalSpace := toTopologicalSpace, toIsTopologicalGroup := toIsTopo... | null | false |
Dynamics.mem_ball_dynEntourage_comp | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} (T : X → X) (n : ℕ) {U : SetRel X X} [U.IsSymm] (x y : X),
(UniformSpace.ball x (Dynamics.dynEntourage T U n) ∩ UniformSpace.ball y (Dynamics.dynEntourage T U n)).Nonempty →
x ∈ UniformSpace.ball y (Dynamics.dynEntourage T (U.comp U) n) | null | true |
MeasureTheory.lintegral_mul_left_eq_self | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : MeasurableSpace G] {μ : MeasureTheory.Measure G} [inst_1 : Group G] [MeasurableMul G]
[μ.IsMulLeftInvariant] (f : G → ENNReal) (g : G), ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ | Translating a function by left-multiplication does not change its Lebesgue integral
with respect to a left-invariant measure. | true |
ValuationSubring.ofPrime_idealOfLE | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (R S : ValuationSubring K) (h : R ≤ S), R.ofPrime (R.idealOfLE S h) = S | null | true |
Nat.coprime_factorial_iff | Mathlib.Data.Nat.Prime.Factorial | ∀ {m n : ℕ}, m ≠ 1 → (m.Coprime n.factorial ↔ n < m.minFac) | null | true |
Subsemigroup.topEquiv_symm_apply_coe | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (x : M), ↑(Subsemigroup.topEquiv.symm x) = x | null | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.map_addNatEmb_Ioi._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
_private.Aesop.Tree.Check.0.Aesop.MVarClusterRef.checkMVars.checkNormMVars.match_1 | Aesop.Tree.Check | (motive : Aesop.NormalizationState → Sort u_1) →
(x : Aesop.NormalizationState) →
(Unit → motive Aesop.NormalizationState.notNormal) →
((postMetaState : Lean.Meta.SavedState) →
(script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))) →
motive (Aesop.Normalization... | null | false |
IncidenceAlgebra.instAddCommGroup._proof_5 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑(f - g) = ⇑f - ⇑g | null | false |
_private.Mathlib.Analysis.BoxIntegral.Box.SubboxInduction.0.BoxIntegral.Box.mem_splitCenterBox._simp_1_4 | Mathlib.Analysis.BoxIntegral.Box.SubboxInduction | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
CategoryTheory.Limits.hasBinaryProduct_zero_right | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[CategoryTheory.Limits.HasZeroMorphisms C] (X : C), CategoryTheory.Limits.HasBinaryProduct X 0 | null | true |
Mathlib.Tactic.DepRewrite.Conv.depRewriteTarget | Mathlib.Tactic.DepRewrite | Lean.Syntax → Bool → optParam Mathlib.Tactic.DepRewrite.Config { } → Lean.Elab.Tactic.TacticM Unit | Apply `rewrite!` to the goal. | true |
CategoryTheory.Limits.PullbackCone.combine._proof_6 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (x ... | null | false |
Array.findIdx?_eq_some_iff_findIdx_eq | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool} {i : ℕ},
Array.findIdx? p xs = some i ↔ i < xs.size ∧ Array.findIdx p xs = i | null | true |
Std.toList_roo_eq_toList_rco_of_isSome_succ? | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {lo hi : α} (h : (Std.PRange.succ? lo).isSome = true),
(lo<...hi).toList = ((Std.PRange.succ? lo... | null | true |
CategoryTheory.Equivalence.congrFullSubcategory_inverse | Mathlib.CategoryTheory.ObjectProperty.Equivalence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{P : CategoryTheory.ObjectProperty C} {Q : CategoryTheory.ObjectProperty D} (e : C ≌ D)
[inst_2 : Q.IsClosedUnderIsomorphisms] (h : Q.inverseImage e.functor = P),
(e.congrFullSubcategory h).inverse... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.List.getValue_filter_containsKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrability.Log.0.MeromorphicOn.circleIntegrable_log_norm._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Integrability.Log | ∀ {E : Type u_4} [inst : NormedAddGroup E] {a : E}, (‖a‖ = 0) = (a = 0) | null | false |
Submodule.coe_mapIic_apply | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(q : Submodule R ↥p), ↑(p.mapIic q) = Submodule.map p.subtype q | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Basic.0.inv_lt_one_iff₀._simp_1_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b | null | false |
Lean.Meta.SimpCongrTheorems.noConfusionType | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Sort u → Lean.Meta.SimpCongrTheorems → Lean.Meta.SimpCongrTheorems → Sort u | null | false |
cfc_comp_re._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | Lean.Syntax | null | false |
Finset.map_disjSum | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Finset α} {t : Finset β} (f : α ⊕ β ↪ γ),
Finset.map f (s.disjSum t) =
(Finset.map (Function.Embedding.inl.trans f) s).disjUnion (Finset.map (Function.Embedding.inr.trans f) t) ⋯ | null | true |
CategoryTheory.CartesianMonoidalCategory.lift_snd_comp_fst_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {W X Y Z : C} (g : W ⟶ X) (g' : Y ⟶ Z),
CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMono... | null | true |
RootPairing.Equiv.weightEquiv_inv | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (g : P.Aut),
g⁻¹.weightEquiv = (RootPairing.Equiv.weightEquiv g)⁻¹ | null | true |
Polynomial.prod_multiset_X_sub_C_dvd | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (p : Polynomial R),
(Multiset.map (fun a => Polynomial.X - Polynomial.C a) p.roots).prod ∣ p | The product `∏ (X - a)` for `a` inside the multiset `p.roots` divides `p`. | true |
CategoryTheory.IsCofiltered.SmallCofilteredIntermediate._proof_1 | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_4, u_2} D] (F : CategoryTheory.Functor D C),
CategoryTheory.EssentiallySmall.{max u_1 u_2, u_1, u_3}
(CategoryTheory.IsCofiltered.cofilteredClosure F... | null | false |
HNNExtension.NormalWord.ReducedWord.ctorIdx | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} → {inst : Group G} → {A B : Subgroup G} → HNNExtension.NormalWord.ReducedWord G A B → ℕ | null | false |
BoxIntegral.TaggedPrepartition.distortion | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} → {I : BoxIntegral.Box ι} → BoxIntegral.TaggedPrepartition I → [Fintype ι] → NNReal | The distortion of a tagged prepartition is the maximum of distortions of its boxes. | true |
IsBaseChange.eq_1 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {M : Type v₁} {N : Type v₂} (S : Type v₃) [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
[inst_2 : CommSemiring R] [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module R N]
[inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (f : M →ₗ[R] N),
IsBaseChange S... | null | true |
UInt64.toUSize_sub | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), (a - b).toUSize = a.toUSize - b.toUSize | null | true |
Matrix.ProjectiveSpecialLinearGroup.toPGL_mk | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Projective | ∀ {n : Type u_1} {R : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
(g : Matrix.SpecialLinearGroup n R),
Matrix.ProjectiveSpecialLinearGroup.toPGL ↑g = Matrix.ProjGenLinGroup.mk (Matrix.SpecialLinearGroup.toGL g) | null | true |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_of_sign_eq._simp_1_1 | Mathlib.Analysis.Convex.Side | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i | null | false |
RootPairing.coroot_reflectionPerm | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (i j : ι),
P.coroot ((P.reflectionPerm i) j) = (P.coreflection i) (P.coroot j) | null | true |
CategoryTheory.PreZeroHypercover.sumInr | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} → (E : CategoryTheory.PreZeroHypercover S) → (F : CategoryTheory.PreZeroHypercover S) → F.Hom (E.sum F) | The right inclusion into the disjoint union. | true |
PosMulStrictMono.toPosMulMono | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] [inst_1 : PartialOrder α] [PosMulStrictMono α], PosMulMono α | null | true |
Lean.Meta.getPropHyps | Lean.Meta.Tactic.Util | Lean.MetaM (Array Lean.FVarId) | Return all propositions in the local context. | true |
PartialHomeomorph.mk.injEq | Mathlib.Topology.PartialHomeomorph.Defs | ∀ {X : Type u_5} {Y : Type u_6} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(toPartialEquiv : PartialEquiv X Y) (continuousOn_toFun : ContinuousOn (↑toPartialEquiv) toPartialEquiv.source)
(continuousOn_invFun : ContinuousOn toPartialEquiv.invFun toPartialEquiv.target) (toPartialEquiv_1 : PartialEquiv ... | null | true |
Matrix.module | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} →
{n : Type u_3} →
{R : Type u_5} →
{α : Type v} → [inst : Semiring R] → [inst_1 : AddCommMonoid α] → [Module R α] → Module R (Matrix m n α) | null | true |
CategoryTheory.Limits.Pi.whiskerEquiv | Mathlib.CategoryTheory.Limits.Shapes.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u_1} →
{K : Type u_2} →
{f : J → C} →
{g : K → C} →
(e : J ≃ K) →
((j : J) → g (e j) ≅ f j) →
[inst_1 : CategoryTheory.Limits.HasProduct f] →
[inst_2 : CategoryT... | Two products which differ by an equivalence in the indexing type,
and up to isomorphism in the factors, are isomorphic.
| true |
FP.Float.Zero.valid | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.ValidFinite FP.emin 0 | null | true |
CliffordAlgebra.equivExterior._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
Nat.shiftRight_succ_inside._f | Init.Data.Nat.Lemmas | ∀ (x : ℕ) (f : Nat.below (motive := fun x => ∀ (x_1 : ℕ), x_1 >>> (x + 1) = (x_1 / 2) >>> x) x) (x_1 : ℕ),
x_1 >>> (x + 1) = (x_1 / 2) >>> x | null | false |
Lean.Parser.nameLit | Lean.Parser.Extra | Lean.Parser.Parser | The parser `name` parses a name literal like `` `foo``. The syntax is the same as for identifiers
(see `ident`) but with a leading backquote.
This parser has arity 1: it produces a `nameLitKind` node containing the raw literal
(including the backquote).
You can use `TSyntax.getName` to extract the name from the result... | true |
WeierstrassCurve.Affine.Point.instInvolutiveNeg | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} → [inst : CommRing R] → {W' : WeierstrassCurve.Affine R} → InvolutiveNeg W'.Point | null | true |
BoundedContinuousFunction.instRing | Mathlib.Topology.ContinuousMap.Bounded.Normed | {α : Type u} →
[inst : TopologicalSpace α] → {R : Type u_1} → [inst_1 : SeminormedRing R] → Ring (BoundedContinuousFunction α R) | null | true |
CategoryTheory.InjectiveResolution.ofCocomplex._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X₀ X₁ : C}
(f : X₀ ⟶ X₁), CategoryTheory.Limits.HasCokernel f | null | false |
Ordinal.toTypeOrderBot._proof_4 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} (ho : o ≠ 0) (a : o.ToType), (Ordinal.enum fun x1 x2 => x1 < x2) ⟨0, ⋯⟩ ≤ a | null | false |
Inclusion.IType.ctorIdx | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.IType → ℕ | null | false |
Std.Sat.CNF.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → Std.Sat.CNF α → Std.Sat.CNF.Clause α → Prop | `Clause` `c` occurs in `CNF` formula `f`.
| true |
Filter.Tendsto.compCM | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [LocallyCompactPair Y Z] {α : Type u_6} {l : Filter α} {g : α → C(Y, Z)} {g₀ : C(Y, Z)}
{f : α → C(X, Y)} {f₀ : C(X, Y)},
Filter.Tendsto g l (nhds g₀) →
Filter.Tendsto f l (nh... | null | true |
CategoryTheory.MorphismProperty.inf_iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (W W' : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y), (W ⊓ W') f = (W f ∧ W' f) | null | false |
zpow_lt_zpow_right | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {m n : ℤ} {a : α},
1 < a → m < n → a ^ m < a ^ n | null | true |
TypeCat.Hom.casesOn | Mathlib.CategoryTheory.Types.Basic | {X Y : Type u} →
{motive : TypeCat.Hom X Y → Sort u_1} →
(t : TypeCat.Hom X Y) → ((hom' : TypeCat.Fun X Y) → motive { hom' := hom' }) → motive t | null | false |
MeasureTheory.StronglyMeasurable.approxBounded | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | {α : Type u_1} →
{β : Type u_2} →
{f : α → β} →
[inst : TopologicalSpace β] →
{x : MeasurableSpace α} →
[Norm β] → [SMul ℝ β] → MeasureTheory.StronglyMeasurable f → ℝ → ℕ → MeasureTheory.SimpleFunc α β | Similar to `stronglyMeasurable.approx`, but enforces that the norm of every function in the
sequence is less than `c` everywhere. If `‖f x‖ ≤ c` this sequence of simple functions verifies
`Tendsto (fun n => hf.approxBounded n x) atTop (𝓝 (f x))`. | true |
Nat.shiftLeft_pos_iff._simp_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n m : ℕ}, (0 < n <<< m) = (0 < n) | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors.0.MvPowerSeries.instNoZeroDivisors._simp_2 | Mathlib.RingTheory.MvPowerSeries.NoZeroDivisors | ∀ {α : Type u} [inst : Add α] {x y : WithTop α}, (x + y = ⊤) = (x = ⊤ ∨ y = ⊤) | null | false |
AlgEquivClass.casesOn | Mathlib.Algebra.Algebra.Equiv | {F : Type u_1} →
{R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
[inst_5 : EquivLike F A B] →
... | null | false |
Lean.Parser.numLitNoAntiquot | Lean.Parser.Basic | Lean.Parser.Parser | null | true |
_private.Mathlib.FieldTheory.Separable.0.Associated.separable._proof_1_1 | Mathlib.FieldTheory.Separable | ∀ {R : Type u_1} [inst : CommSemiring R] {f g : Polynomial R}, Associated f g → f.Separable → g.Separable | null | false |
Subalgebra.unop_op | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A), S.op.unop = S | null | true |
Valuation.RankOne.restrict_RankOne._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] (K : Type u_2) [inst_1 : DivisionRing K]
(v : Valuation K Γ₀) [inst_2 : v.RankOne],
StrictMono (⇑(Valuation.RankOne.hom v) ∘ ⇑MonoidWithZeroHom.ValueGroup₀.embedding) | null | false |
QuotSMulTop.equivQuotTensor._proof_3 | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_2} [inst : CommRing R] (r : R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
r • ⊤ = Ideal.span {r} • ⊤ | null | false |
Array.foldrM.fold._unsafe_rec | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (α → β → m β) → (as : Array α) → ℕ → (i : ℕ) → i ≤ as.size → β → m β | null | false |
IsPredArchimedean.mk | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_3} [inst : Preorder α] [inst_1 : PredOrder α],
(∀ {a b : α}, a ≤ b → ∃ n, Order.pred^[n] b = a) → IsPredArchimedean α | null | true |
TopCat.Presheaf.EtaleSpace.base | Mathlib.Topology.Sheaves.EtaleSpace | {X : TopCat} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{CC : C → Type v} →
{FC : C → C → Type w} →
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] →
[inst_2 : CategoryTheory.ConcreteCategory C FC] →
[inst_3 : CategoryTheory.Limits.HasColim... | The base point. | true |
Lean.Expr.ProdTree._sizeOf_1 | Mathlib.Tactic.ProdAssoc | Lean.Expr.ProdTree → ℕ | null | false |
Polynomial.toFinsupp_C_mul_X | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : R), (Polynomial.C a * Polynomial.X).toFinsupp = AddMonoidAlgebra.single 1 a | null | true |
Set.Finite.toFinset_nontrivial._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α} (h : s.Finite), h.toFinset.Nontrivial = s.Nontrivial | null | false |
Prod.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Prod | {M₀ : Type u_1} → {N₀ : Type u_2} → [MonoidWithZero M₀] → [MonoidWithZero N₀] → MonoidWithZero (M₀ × N₀) | null | true |
ContinuousCohomology.cochainsMap._proof_2 | Mathlib.RepresentationTheory.Homological.ContCohomology.Functoriality | IsRightCancelAdd ℕ | null | false |
Batteries.UnionFind.parent_push | Batteries.Data.UnionFind.Lemmas | ∀ {a : ℕ} {m : Batteries.UnionFind}, m.push.parent a = m.parent a | null | true |
Lean.Parser.Term.valueOf | Lean.Parser.Term | Lean.Parser.Parser | `value_of% x` elaborates to the value of `x`, which can be a local or global definition.
| true |
Std.DTreeMap.Internal.Impl.maxKey!_eq_maxKey! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : Inhabited α] [inst_3 : BEq α]
[Std.LawfulBEqOrd α] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.maxKey! = Std.Internal.List.maxKey! t.toListModel | null | true |
Ideal.span_iUnion | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Sort u_1} (s : ι → Set α), Ideal.span (⋃ i, s i) = ⨆ i, Ideal.span (s i) | null | true |
CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject.Augmented C),
(CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X).right = X.right.obj { len := 0 } | null | true |
ContinuousMap.coeFnAlgHom | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
[inst : TopologicalSpace α] →
(R : Type u_2) →
[inst_1 : CommSemiring R] →
{A : Type u_3} →
[inst_2 : TopologicalSpace A] →
[inst_3 : Semiring A] → [inst_4 : Algebra R A] → [inst_5 : IsTopologicalSemiring A] → C(α, A) →ₐ[R] α → A | Coercion to a function as an `AlgHom`. | true |
op_smul_eq_mul | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Mul α] (a b : α), MulOpposite.op a • b = b * a | null | true |
CategoryTheory.OverClass.asOverHom_comp | Mathlib.CategoryTheory.Comma.Over.OverClass | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (S : C) [inst_1 : CategoryTheory.OverClass X S]
[inst_2 : CategoryTheory.OverClass Y S] [inst_3 : CategoryTheory.OverClass Z S] (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_4 : CategoryTheory.HomIsOver f S] [inst_5 : CategoryTheory.HomIsOver g S],
CategoryTheo... | null | true |
Aesop.BaseM.instMonadHashMapCacheAdapterExprEntry | Aesop.BaseM | Lean.MonadHashMapCacheAdapter Lean.Expr Aesop.RulePatternCache.Entry Aesop.BaseM | null | true |
BigOperators.delabFinsetExpect | Mathlib.Algebra.BigOperators.Expect | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `Finset.expect`. The `pp.funBinderTypes` option controls whether
to show the domain type when the expect is over `Finset.univ`. | true |
Std.TreeMap.getElem!_alter | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k k' : α}
[inst : Inhabited β] {f : Option β → Option β},
(t.alter k f)[k']! = if cmp k k' = Ordering.eq then (f t[k]?).get! else t[k']! | null | true |
_private.Mathlib.Data.Vector3.0.Vector3.eq_nil.match_1_1 | Mathlib.Data.Vector3 | ∀ (motive : Fin2 0 → Prop) (i : Fin2 0), motive i | null | false |
AddMonoidAlgebra.lift_mapRangeRingHom_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : AddMonoid M]
[inst_2 : Semiring A] [inst_3 : Algebra R A] [inst_4 : CommSemiring S] [inst_5 : Algebra S A] [inst_6 : Algebra R S]
[IsScalarTower R S A] (f : Multiplicative M →* A) (x : AddMonoidAlgebra R M),
((AddMonoi... | **Alias** of `AddMonoidAlgebra.lift_mapRingHom_algebraMap`. | true |
MvPowerSeries.nat_le_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R} {n : ℕ},
(∀ (d : σ →₀ ℕ), (Finsupp.weight w) d < n → (MvPowerSeries.coeff d) f = 0) → ↑n ≤ MvPowerSeries.weightedOrder w f | The order of a formal power series is at least `n` if
the `d`th coefficient is `0` for all `d` such that `weight w d < n`. | true |
SzemerediRegularity.card_eq_of_mem_parts_chunk | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {s : Finset α},
s ∈ (SzemerediRegularity.chunk hP G ε hU).parts →
s.card = Fintype.card α / SzemerediRe... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.