name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.DepRewrite.Context.h | Mathlib.Tactic.DepRewrite | Mathlib.Tactic.DepRewrite.Context → Lean.Expr | A proof of `p = x`. Must be an fvar. | true |
ProbabilityTheory.Kernel.eq_zero_of_isEmpty_left | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[h : IsEmpty α], κ = 0 | null | true |
PadicInt.continuousAddCharEquiv_of_norm_mul_apply | Mathlib.NumberTheory.Padics.AddChar | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : NormedRing R] [inst_2 : Algebra ℤ_[p] R]
[inst_3 : IsBoundedSMul ℤ_[p] R] [inst_4 : IsUltrametricDist R] [inst_5 : CompleteSpace R] [inst_6 : NormMulClass R]
{κ : AddChar ℤ_[p] R} (hκ : Continuous ⇑κ), ↑((PadicInt.continuousAddCharEquiv_of_norm_mul p R)... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.LawfulForwardPatternModel.skipPrefix?_eq_none_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat]
[inst_1 : String.Slice.Pattern.Model.PatternModel pat] [String.Slice.Pattern.Model.LawfulForwardPatternModel pat]
{s : String.Slice} {p₀ : s.Pos},
(String.Slice.Pattern.ForwardPattern.skipPrefix? pat (s.sliceFrom p₀) = none) =
¬String.Sli... | null | false |
_private.Mathlib.RingTheory.Teichmuller.0.Perfection.teichmullerAux.match_1.eq_1 | Mathlib.RingTheory.Teichmuller | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
Ideal.span_pair_sub_right | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Ring α] (x y : α), Ideal.span {x - y, y} = Ideal.span {x, y} | null | true |
CategoryTheory.Functor.isoShift_inv_naturality | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A) {M : Type u_4} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] (n : M) {X Y : C} (f : X ⟶ Y),
CategoryTheory.Cat... | null | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.roughNumbersUpTo_eq_biUnion._simp_1_12 | Mathlib.NumberTheory.SmoothNumbers | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (b ∧ ∃ x, p x) = ∃ x, b ∧ p x | null | false |
Lean.Meta.DefEq.isInstHAddNat | Lean.Meta.NatInstTesters | Lean.Expr → Lean.MetaM Bool | null | true |
Lean.Elab.ConfigEval.configEntryHandlerKey | Lean.Elab.ConfigEval.Commands | Lean.ParserDescr | - `key` matches a specific key
- `key.*` matches any keys for which `key` is a proper prefix
- `*` matches all keys
| true |
GromovHausdorff.optimalGHInjl | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | (X : Type u) →
(Y : Type v) →
[inst : MetricSpace X] →
[inst_1 : CompactSpace X] →
[inst_2 : Nonempty X] →
[inst_3 : MetricSpace Y] →
[inst_4 : CompactSpace Y] → [inst_5 : Nonempty Y] → X → GromovHausdorff.OptimalGHCoupling X Y | Injection of `X` in the optimal coupling between `X` and `Y` | true |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.tensor.noConfusion | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
{P : Sort u_1} →
{a : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C} →
{a_1 : C} →
{a' : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C} →
{a'_1 : C} → a.tensor a_1 = a'.tensor a'_1 → (a ≍ a' → a_1 ≍ a'_1 → P) → P | null | false |
WeierstrassCurve.Affine.CoordinateRing.XYIdeal | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} → [inst : CommRing R] → (W' : WeierstrassCurve.Affine R) → R → Polynomial R → Ideal W'.CoordinateRing | The ideal `⟨X - x, Y - y(X)⟩` of `R[W]` for some `x` in `R` and `y(X)` in `R[X]`. | true |
UniformSpace.Completion.instField._proof_9 | Mathlib.Topology.Algebra.UniformField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : UniformSpace K] [IsTopologicalDivisionRing K], IsTopologicalRing K | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.matchPrefix._proof_2 | Lean.Util.Diff | ∀ {α : Type u_1} (left right : Subarray α) (pref : Array α),
pref.size < Std.Slice.size left ∧ pref.size < Std.Slice.size right → ¬pref.size < Std.Slice.size right → False | null | false |
Set.isSelfNeg_iff_subset_neg | Mathlib.Algebra.Group.Pointwise.Set.SelfInv | ∀ {α : Type u_1} [inst : InvolutiveNeg α] {s : Set α}, IsSelfNeg s ↔ s ⊆ -s | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_eq._simp_1_7 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
Nat.Subtype.succ._proof_1 | Mathlib.Basic.Denumerable | ∀ {s : Set ℕ} [inst : DecidablePred fun x => x ∈ s] (x : ↑s) (h : ∃ m, ↑x + m + 1 ∈ s), ↑x + Nat.find h + 1 ∈ s | null | false |
Lean.Meta.instInhabitedAltVarNames | Lean.Meta.Tactic.Induction | Inhabited Lean.Meta.AltVarNames | null | true |
Std.DTreeMap.Internal.Impl.minKey_le_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} (hc : k ∈ t), (compare (t.minKey ⋯) k).isLE = true | null | true |
Ideal.quotEquivOfEq._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Defs | ∀ {R : Type u_1} [inst : Ring R] {I J : Ideal R} [inst_1 : I.IsTwoSided] [inst_2 : J.IsTwoSided] (h : I = J)
(x y : R ⧸ I),
(↑(Submodule.quotEquivOfEq I J h)).toFun (x * y) =
(↑(Submodule.quotEquivOfEq I J h)).toFun x * (↑(Submodule.quotEquivOfEq I J h)).toFun y | null | false |
CategoryTheory.Limits.reflexivePair_obj_zero | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B) (s : B ⟶ A)
{sl : CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B}
{sr : CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B},
(CategoryTheory.Limits.reflexivePair f g s sl sr).obj ... | null | true |
String.Slice.contains_bool_eq | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Char → Bool} {s : String.Slice}, s.contains p = s.copy.toList.any p | null | true |
Set.Finite.toFinset_smul | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] [inst_1 : DecidableEq β] {s : Set α} {t : Set β} (hs : s.Finite)
(ht : t.Finite) (hf : optParam (s • t).Finite ⋯), hf.toFinset = hs.toFinset • ht.toFinset | null | true |
Polynomial.natCast_inj._simp_1 | Mathlib.Algebra.Polynomial.Coeff | ∀ {m n : ℕ} {R : Type u_1} [inst : Semiring R] [CharZero R], (↑m = ↑n) = (m = n) | null | false |
Std.ExtTreeSet.size_le_size_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.size ≤ (t.erase k).size + 1 | null | true |
LinearIsometry.postcomp | Mathlib.Analysis.Normed.Operator.NormedSpace | {𝕜 : Type u_1} →
{𝕜₂ : Type u_3} →
{𝕜₃ : Type u_4} →
{E : Type u_5} →
{F : Type u_6} →
{G : Type u_8} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : SeminormedAddCommGroup F] →
[inst_2 : SeminormedAddCommGroup G] →
[inst_3 : N... | Composing on the left with a linear isometry gives a linear isometry between spaces of
continuous linear maps. | true |
AbsoluteValue.map_prod | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : CommSemiring R] [Nontrivial R] [inst_2 : CommRing S]
[inst_3 : LinearOrder S] [IsStrictOrderedRing S] (abv : AbsoluteValue R S) (f : ι → R) (s : Finset ι),
abv (∏ i ∈ s, f i) = ∏ i ∈ s, abv (f i) | null | true |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.Hom.hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F :
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ)
(CategoryTheory.Bicategory.Adj CategoryTheory.Cat)} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} → {D₁ D₂ : F.... | The morphisms between the `obj` fields of descent data. | true |
CovBy.exists_multiset_cons | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Multiset α}, s ⋖ t → ∃ a, a ::ₘ s = t | null | true |
_private.Lean.Meta.Sym.LooseBVarsS.0.Lean.Meta.Sym.lowerLooseBVarsS'._sparseCasesOn_1 | Lean.Meta.Sym.LooseBVarsS | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceEq._regBuiltin.BitVec.reduceEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.2662256279._hygCtx._hyg.30 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Set.Subsingleton.isPreirreducible | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s.Subsingleton → IsPreirreducible s | null | true |
Dyadic.ctorElim | Init.Data.Dyadic.Basic | {motive : Dyadic → Sort u} → (ctorIdx : ℕ) → (t : Dyadic) → ctorIdx = t.ctorIdx → Dyadic.ctorElimType ctorIdx → motive t | null | false |
TopCat.Presheaf.pushforwardToOfIso_app._proof_1 | Mathlib.Topology.Sheaves.Presheaf | ∀ {X Y : TopCat} (H₁ : X ≅ Y) (U : (TopologicalSpace.Opens ↑X)ᵒᵖ),
(TopologicalSpace.Opens.map H₁.hom).op.obj (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U))) =
U | null | false |
Real.tan_eq_one_sub_tan_half_sq_div_one_add_tan_half_sq | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ (x : ℝ), Real.tan x = 2 * Real.tan (x / 2) / (1 - Real.tan (x / 2) ^ 2) | null | true |
_private.Mathlib.NumberTheory.EulerProduct.DirichletLSeries.0.DirichletCharacter.LSeries_changeLevel._simp_1_8 | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | null | false |
ContinuousMap.sigmaEquiv._proof_2 | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_1} (A : Type u_2) (X : I → Type u_3) [inst : TopologicalSpace A]
[inst_1 : (i : I) → TopologicalSpace (X i)],
Function.RightInverse (fun f i => f.comp (ContinuousMap.sigmaMk i)) ContinuousMap.sigma | null | false |
BitVec.signExtend_and | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} {x y : BitVec w}, BitVec.signExtend v (x &&& y) = BitVec.signExtend v x &&& BitVec.signExtend v y | null | true |
_private.Mathlib.Topology.ContinuousMap.Bounded.Normed.0.BoundedContinuousFunction.norm_add_eq_max._simp_1_3 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (max a b ≤ c) = (a ≤ c ∧ b ≤ c) | null | false |
Lean.Meta.InjectionResult.subgoal.sizeOf_spec | Lean.Meta.Tactic.Injection | ∀ (mvarId : Lean.MVarId) (newEqs : Array Lean.FVarId) (remainingNames : List Lean.Name),
sizeOf (Lean.Meta.InjectionResult.subgoal mvarId newEqs remainingNames) =
1 + sizeOf mvarId + sizeOf newEqs + sizeOf remainingNames | null | true |
Int64.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int64}, (a ^^^ b = 0) = (a = b) | null | false |
MulDistribMulActionHom.map_smulₑ | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : Monoid A]
[inst_3 : MulDistribMulAction M A] {B : Type u_5} [inst_4 : Monoid B] [inst_5 : MulDistribMulAction N B]
(f : A →ₑ*[φ] B) (m : M) (x : A), f (m • x) = φ m • f x | null | true |
Std.Tactic.BVDecide.LRAT.parseLRATProof | Std.Tactic.BVDecide.LRAT.Parser | ByteArray → Except String (Array Std.Tactic.BVDecide.LRAT.IntAction) | Parse `proof` as an LRAT proof. `proof` may contain either the binary or the non-binary LRAT format.
| true |
Nat.dist_mul_left | Mathlib.Data.Nat.Dist | ∀ (k n m : ℕ), (k * n).dist (k * m) = k * n.dist m | null | true |
Inclusion.IType._sizeOf_inst | Mathlib.Tactic.Inclusion.Core.Types | SizeOf Inclusion.IType | null | false |
AlgebraicGeometry.specOrderIsoPrimeSpectrum | Mathlib.AlgebraicGeometry.Scheme | (R : CommRingCat) → ↥(AlgebraicGeometry.Spec R) ≃o (PrimeSpectrum ↑R)ᵒᵈ | `Spec R` with the specialization order is order isomorphic to the dual of the prime
spectrum of `R`. | true |
ArchimedeanClass | Mathlib.Algebra.Order.Archimedean.Class | (M : Type u_1) → [inst : AddCommGroup M] → [inst_1 : LinearOrder M] → [IsOrderedAddMonoid M] → Type u_1 | `ArchimedeanClass M` is the quotient of the additive group `M` by additive archimedean
equivalence, where two elements `a` and `b` are in the same class iff
`(∃ m : ℕ, |b| ≤ m • |a|) ∧ (∃ n : ℕ, |a| ≤ n • |b|)`. | true |
CategoryTheory.Limits.WidePushoutShape.mkCocone.match_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type u_1} →
(motive : CategoryTheory.Limits.WidePushoutShape J → Sort u_2) →
(j : CategoryTheory.Limits.WidePushoutShape J) → (Unit → motive none) → ((j : J) → motive (some j)) → motive j | null | false |
Batteries.Random.MersenneTwister.State.mk.sizeOf_spec | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (data : Vector (BitVec cfg.wordSize) cfg.stateSize)
(index : Fin cfg.stateSize), sizeOf { data := data, index := index } = 1 + sizeOf data + sizeOf index | null | true |
CompactlySupportedContinuousMap.coe_comp_to_continuous_fun | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {β : Type u_3} {γ : Type u_4} {δ : Type u_5} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
[inst_2 : TopologicalSpace δ] [inst_3 : Zero δ] (f : CompactlySupportedContinuousMap γ δ) (g : CocompactMap β γ),
⇑(f.comp g) = ⇑f ∘ ⇑g | null | true |
_private.Mathlib.Data.Nat.Log.0.Nat.log_lt_of_lt_pow'._proof_1_1 | Mathlib.Data.Nat.Log | ∀ {b x : ℕ}, x ≠ 0 → Nat.log b 0 < x | null | false |
_private.Init.Data.String.PosRaw.0.String.Pos.Raw.le_refl._simp_1_1 | Init.Data.String.PosRaw | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ ≤ i₂) = (i₁.byteIdx ≤ i₂.byteIdx) | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.α.eq_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [inst_2 : CategoryTheory.EnoughInjectives C] (n : ℤ),
CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.α✝ f n =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limi... | null | true |
_private.Mathlib.Condensed.Discrete.Module.0.LightCondMod.LocallyConstant.instIsIsoLightCondSetMapForgetAppLightCondensedModuleCatCounitDiscreteUnderlyingAdjObjFunctor._proof_2 | Mathlib.Condensed.Discrete.Module | (CategoryTheory.constantSheaf (CategoryTheory.coherentTopology LightProfinite) (Type u_1)).Full | null | false |
Finset.Nontrivial.exists_cons_eq | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} {s : Finset α},
s.Nontrivial → ∃ t a, ∃ (ha : a ∉ t), ∃ b, ∃ (hb : b ∉ t) (hab : ¬a = b), Finset.cons a (Finset.cons b t hb) ⋯ = s | null | true |
CategoryTheory.GlueData.π_epi | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] [inst_2 : CategoryTheory.Limits.HasColimits C],
CategoryTheory.Epi D.π | null | true |
Convexity.IsConvexSet.singleton._simp_1 | Mathlib.Geometry.Convex.Set | ∀ {R : Type u_3} {X : Type u_5} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : Convexity.ConvexSpace R X] {x : X}, Convexity.IsConvexSet R {x} = True | null | false |
Representation.le_stabilizer_add | Mathlib.RepresentationTheory.Stabilizer | ∀ {k : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Semiring k] {V : Type u_3} [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (v1 v2 : V),
ρ.stabilizer v1 ⊓ ρ.stabilizer v2 ≤ ρ.stabilizer (v1 + v2) | null | true |
WeakPseudoEMetricSpace.rec | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
[τ : TopologicalSpace α] →
{motive : WeakPseudoEMetricSpace α → Sort u_1} →
([toEDist : EDist α] →
(edist_self : ∀ (x : α), edist x x = 0) →
(edist_comm : ∀ (x y : α), edist x y = edist y x) →
(edist_triangle : ∀ (x y z : α), edist x z ≤ edist x y + edist y... | null | false |
spectralNorm_unique_of_finiteDimensional_normal | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u_2) [inst : NormedField K] (L : Type u_3) [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hn : Normal K L] {f : AlgebraNorm K L},
IsPowMul ⇑f →
IsNonarchimedean ⇑f →
(∀ (x : K), f ((algebraMap K L) x) = ↑‖x‖₊) →
(∀ (σ : Gal(L/K)) (x : L), f x = f (σ x)) → ∀ ... | If `L/K` is finite and normal, and `f` is a power-multiplicative `K`-algebra norm on `L`
extending the norm on `K`, then `f = spectralNorm K L`. | true |
Nat.IsCarmichael.probablePrime_of_coprime | Mathlib.NumberTheory.CarmichaelNumber | ∀ {n b : ℕ}, n.IsCarmichael → b.Coprime n → n.ProbablePrime b | null | true |
Std.ExtDTreeMap.Const.distinct_keys_toList | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp],
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) (Std.ExtDTreeMap.Const.toList t) | null | true |
CategoryTheory.GradedNatTrans.recOn | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.EnrichedCategory V D] →
{A : CategoryTheory.Center V... | null | false |
Eq.cmp_eq_eq | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α}, x = y → cmp x y = Ordering.eq | null | true |
Associates.out_mul' | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] (a b : Associates α),
Associated (a * b).out (a.out * b.out) | null | true |
LowerSet.map_map | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{s : LowerSet α} (g : β ≃o γ) (f : α ≃o β), (LowerSet.map g) ((LowerSet.map f) s) = (LowerSet.map (f.trans g)) s | null | true |
IsCofinal | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → Prop | A set is cofinal when for every `x : α` there exists `y ∈ s` with `x ≤ y`. | true |
Real.arctan_strictMono | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | StrictMono Real.arctan | null | true |
Num.cast_inj._simp_1 | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] {m n : Num}, (↑m = ↑n) = (m = n) | null | false |
AlgebraicGeometry.SheafedSpace.restrictTopIso._proof_1 | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (X : AlgebraicGeometry.SheafedSpace C),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom ⊤.inclusion') | null | false |
Lean.ImportM.Context.opts | Lean.Environment | Lean.ImportM.Context → Lean.Options | null | true |
Sum.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{t : α ⊕ β} →
{α' : Type u} → {β' : Type v} → {t' : α' ⊕ β'} → α = α' → β = β' → t ≍ t' → Sum.noConfusionType P t t' | null | false |
FiniteMulArchimedeanClass.mem_toUpperSetMulArchimedeanClass._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M]
{s : UpperSet (FiniteMulArchimedeanClass M)} {a : MulArchimedeanClass M},
(a ∈ FiniteMulArchimedeanClass.toUpperSetMulArchimedeanClass s) = ∀ (h : a ≠ ⊤), ⟨a, h⟩ ∈ s | null | false |
TrivSqZeroExt.addGroup._proof_8 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroup R] [inst_1 : AddGroup M] (n : ℕ) (a : TrivSqZeroExt R M),
↑n.succ • a = ↑n • a + a | null | false |
List.range_map_iterate | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} (n : ℕ) (f : α → α) (a : α), List.map (fun x => f^[x] a) (List.range n) = List.iterate f a n | null | true |
CategoryTheory.Limits.Types.Small.limitCone_pt_ext | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
[inst_1 : Small.{u, max u v} ↑F.sections] {x y : (CategoryTheory.Limits.Types.Small.limitCone F).pt},
(equivShrink ↑F.sections).symm x = (equivShrink ↑F.sections).symm y → x = y | null | true |
AlgebraicGeometry.Scheme.PartialIso.noConfusionType | Mathlib.AlgebraicGeometry.Birational.Birational | Sort u_1 →
{X Y : AlgebraicGeometry.Scheme} → X.PartialIso Y → {X' Y' : AlgebraicGeometry.Scheme} → X'.PartialIso Y' → Sort u_1 | null | false |
CategoryTheory.Abelian.Ext.comp_assoc._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {a₁ a₂ a₃ a₁₂ a : ℕ}, a₁ + a₂ = a₁₂ → a₁ + a₂ + a₃ = a → a₁₂ + a₃ = a | null | false |
UniformSpace.Completion.coe_injective | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α] [T0Space α], Function.Injective UniformSpace.Completion.coe' | null | true |
NonnegSpectrumClass.casesOn | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | {𝕜 : Type u_3} →
{A : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : PartialOrder 𝕜] →
[inst_2 : NonUnitalRing A] →
[inst_3 : PartialOrder A] →
[inst_4 : Module 𝕜 A] →
{motive : NonnegSpectrumClass 𝕜 A → Sort u} →
(t : NonnegSpectrumClass 𝕜 ... | null | false |
IsInvariantSubfield | Mathlib.FieldTheory.Fixed | (M : Type u) → [inst : Monoid M] → {F : Type v} → [inst_1 : Field F] → [MulSemiringAction M F] → Subfield F → Prop | A typeclass for subrings invariant under a `MulSemiringAction`. | true |
ContinuousLinearMap.opNorm | Mathlib.Analysis.Normed.Operator.Basic | {𝕜 : Type u_1} →
{𝕜₂ : Type u_2} →
{E : Type u_4} →
{F : Type u_5} →
[inst : SeminormedAddCommGroup E] →
[inst_1 : SeminormedAddCommGroup F] →
[inst_2 : NontriviallyNormedField 𝕜] →
[inst_3 : NontriviallyNormedField 𝕜₂] →
[inst_4 : NormedSpace ... | The operator norm of a continuous linear map is the inf of all its bounds. | true |
Complex.UnitClosedDisc.instMonoidWithZero | Mathlib.Analysis.Complex.UnitDisc.Basic | MonoidWithZero Complex.UnitClosedDisc | null | true |
Set.image2_subset_iff_right | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
Set.image2 f s t ⊆ u ↔ ∀ b ∈ t, (fun a => f a b) '' s ⊆ u | null | true |
List.pairwise_idxsOf | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} {s : ℕ} [inst : BEq α], List.Pairwise (fun x1 x2 => x1 < x2) (List.idxsOf x xs s) | null | true |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_5} {ι : Type u_1} {E : ι → Type u_4} {F : Type u_2} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopological... | null | false |
AddCon.comapQuotientEquivOfSurj | Mathlib.GroupTheory.Congruence.Basic | {M : Type u_1} →
{N : Type u_2} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
(c : AddCon M) → (f : N →+ M) → Function.Surjective ⇑f → (AddCon.comap ⇑f ⋯ c).Quotient ≃+ c.Quotient | If e : M →* N is surjective then (c.comap e).Quotient ≃* c.Quotient with c :
AddCon N | true |
_private.Mathlib.Basic.IsEmpty.Basic.0.isEmpty_plift._simp_1_1 | Mathlib.Basic.IsEmpty.Basic | ∀ {α : Sort u_1}, IsEmpty α = ¬Nonempty α | null | false |
Nat.pow_add_mul_totient_mod_eq | Mathlib.NumberTheory.PowModTotient | ∀ {x k l n : ℕ}, 1 < n → x.Coprime n → x ^ (k + l * n.totient) % n = x ^ k % n | null | true |
StarModule.selfAdjointPart_add_skewAdjointPart | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) {A : Type u_2} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x : A), ↑((selfAdjointPart R) x) + ↑((skewAdjointPart R) x) = x | null | true |
Homeomorph.isPathConnected_preimage._simp_1 | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set Y} (h : X ≃ₜ Y),
IsPathConnected (⇑h ⁻¹' s) = IsPathConnected s | null | false |
CategoryTheory.Limits.pullback.fst_of_mono | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Mono g],
CategoryTheory.Mono (CategoryTheory.Limits.pullback.fst f g) | The pullback of a monomorphism is a monomorphism | true |
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_mul._proof_1_9 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} {l i : ℕ} (A : List (List α)), i < l → (List.rightpad l [] A).getD i [] = A.getD i [] | null | false |
Lean.MVarId.getTag | Lean.Meta.Tactic.Util | Lean.MVarId → Lean.MetaM Lean.Name | Get the user name of the given metavariable. | true |
IsLocalizedModule.mapExtendScalars._proof_2 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
CategoryTheory.Center.instMonoidalOfBraided._proof_4 | Mathlib.CategoryTheory.Monoidal.Center | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (U : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CategoryStruct.id
((Category... | null | false |
CategoryTheory.leftRigidCategoryOfEquivalence | Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence | {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] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
[F.... | Pull back a left rigid structure along an equivalence. | true |
NonemptyInterval.commMonoid._proof_5 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
autoParam (∀ (n : ℕ) (x : NonemptyInterval α), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
BoundedContinuousFunction.range_toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : MeasureTheory.IsFiniteMeasure μ] {𝕜 : Type u_3}
[inst_5 : Fact (1 ≤ p)] [... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.