name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddMonoidWithOne.binary._proof_3 | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoid R] [inst_1 : One R], Nat.binCast 0 = 0 | null | false |
ContinuousLinearEquiv._sizeOf_1 | Mathlib.Topology.Algebra.Module.Equiv.Basic | {R : Type u_1} →
{S : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
{σ : R →+* S} →
{σ' : S →+* R} →
{inst_2 : RingHomInvPair σ σ'} →
{inst_3 : RingHomInvPair σ' σ} →
{M : Type u_3} →
{inst_4 : TopologicalSpace M} →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_union_of_contains_eq_false_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Finpartition.ofPairwiseDisjoint._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] (parts : Finset α), parts.sup id = parts.sup id | null | false |
ProfiniteAddGrp.ProfiniteCompletion.finiteAddGrpDiagram | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | (G : AddGrpCat) → CategoryTheory.Functor (FiniteIndexNormalAddSubgroup ↑G) FiniteAddGrp.{u} | The diagram of finite quotients indexed by finite-index normal subgroups. | true |
Array.Matcher.state._default | Batteries.Data.Array.Match | {α : Type u_1} → (table : Array.PrefixTable α) → Fin (table.size + 1) | null | false |
Std.PRange.instPreservesLTOfLawfulOrderLTOfPreservesLE | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : LE α] [inst_3 : LT α] [Std.LawfulOrderLT α] [inst_5 : LE β] [inst_6 : LT β] [Std.LawfulOrderLT β]
(f : Std.PRange.UpwardEnumerable.Map α β) [f.PreservesLE], f.PreservesLT | null | true |
CommHopfAlgCat.forget_obj | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u} [inst : CommRing R] (A : CommHopfAlgCat R), (CategoryTheory.forget (CommHopfAlgCat R)).obj A = ↑A | null | true |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.SmallConstruction.Witness.base.injEq | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C} {ι : C → Type w} (X : C)
(a a_1 : ι X),
(CategoryTheory.Precoverage.SmallConstruction.Witness.base✝ X a =
CategoryTheory.Precoverage.SmallConstruction.Witness.base✝ X a_1) =
(a = a_1) | null | true |
Prod.instAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
Prod.instAddCommMonoid = { toAddMonoid := Prod.instAddMonoid, add_comm := ⋯ } | null | true |
_private.Init.Data.Nat.Internal.SOM.0.Nat.Internal.SOM.Poly.add_denote._simp_1_3 | Init.Data.Nat.Internal.SOM | ∀ (n m k : ℕ), n * k + m * k = (n + m) * k | null | false |
_private.Init.Data.List.Zip.0.List.zipWith_eq_append_iff._simp_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {xs : List α}, ([] = xs) = (xs = []) | null | false |
PowerSeries.coeff_subst_finite | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] {τ : Type u_3} {S : Type u_4} [inst_1 : CommRing S] [inst_2 : Algebra R S]
{a : MvPowerSeries τ S},
PowerSeries.HasSubst a →
∀ (f : PowerSeries R) (e : τ →₀ ℕ),
Function.HasFiniteSupport fun d => (PowerSeries.coeff d) f • (MvPowerSeries.coeff e) (a ^ d) | null | true |
ContinuousOn.image_Iic_of_monotoneOn | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a : α} {f : α → δ},
ContinuousOn f (Set.Iic a) →
MonotoneOn f (Set.Iic a) → Filter.Tendst... | null | true |
Real.logb_pos | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 1 < x → 0 < Real.logb b x | null | true |
Equiv.neg.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ (G : Type u_14) [inst : InvolutiveNeg G], Equiv.neg G = Function.Involutive.toPerm Neg.neg ⋯ | null | true |
InnerProductGeometry.angle_zero_right | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x : V),
InnerProductGeometry.angle x 0 = Real.pi / 2 | The angle between a vector and the zero vector. | true |
Std.DTreeMap.Internal.Impl.Const.minEntryD._unary.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : Type v} (_x : (_ : Std.DTreeMap.Internal.Impl α fun x => β) ×' α × β),
Std.DTreeMap.Internal.Impl.Const.minEntryD._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Std.DTreeMap.Internal.Impl.leaf, fallback => fallback
| Std.DTreeMap.Internal.Impl.inner size k v S... | null | false |
IsDedekindDomain.instCommRingFiniteAdeleRing._proof_19 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a : IsDedekindDomain.FiniteAdeleRing R K), a * 1 = a | null | false |
PeriodPair.lattice_eq_span_range_basis | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), L.lattice = Submodule.span ℤ (Set.range ⇑L.basis) | null | true |
ContinuousLinearEquiv.smulLeft._proof_2 | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {M₁ : Type u_1} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {G : Type u_2} [inst_2 : Group G]
[inst_3 : DistribMulAction G M₁] [ContinuousConstSMul G M₁] (g : G), Continuous fun x => g⁻¹ • x | null | false |
Filter.Germ.const_le_iff | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : LE β] [l.NeBot] {x y : β}, ↑x ≤ ↑y ↔ x ≤ y | null | true |
String.Slice.Pos.mk._flat_ctor | Init.Data.String.Defs | {s : String.Slice} → (offset : String.Pos.Raw) → String.Pos.Raw.IsValidForSlice s offset → s.Pos | null | false |
Lean.Meta.getCongrSimpKindsForArgZero | Lean.Meta.CongrTheorems | Lean.Meta.FunInfo → Lean.MetaM (Array Lean.Meta.CongrArgKind) | Variant of `getCongrSimpKinds` for rewriting just argument 0.
If it is possible to rewrite, the 0th `CongrArgKind` is `.eq`,
and otherwise it is `.fixed`. This is used for the `arg` conv tactic.
| true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.subcomplex_le_horn_iff._proof_1_3 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ} (d : ℕ), n ≤ d → ∀ (S : Finset (Fin (n + 1 + 1))), S.card = d + 1 → n < d → n + 1 + 1 ≤ S.card | null | false |
NormedAddGroup.uniformity_basis_dist | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E], (uniformity E).HasBasis (fun ε => 0 < ε) fun ε => {p | ‖-p.1 + p.2‖ < ε} | null | true |
Lean.Doc.DeferredCheck.check | Lean.DocString.DeferredCheck | Lean.Doc.DeferredCheck → Dynamic | The check-specific data. The name of the type in the `Dynamic` determines which checks are to be
performed.
| true |
Lean.Elab.Command.InductiveView.mk._flat_ctor | Lean.Elab.MutualInductive | Lean.Syntax →
Lean.Syntax →
Lean.Elab.Modifiers →
Bool →
Bool →
Bool →
Lean.Name →
Lean.Name →
List Lean.Name →
Lean.Syntax →
Option Lean.Syntax →
Array Lean.Elab.Command.CtorView →
... | null | false |
Std.TreeMap.getKey_maxKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{he : t.isEmpty = false} {hc : t.maxKey he ∈ t}, t.getKey (t.maxKey he) hc = t.maxKey he | null | true |
Stream'.WSeq.updateNth.match_1 | Mathlib.Data.WSeq.Defs | {α : Type u_1} →
(motive : Option (Stream'.Seq1 (Option α)) → ℕ → Sort u_2) →
(x : Option (Stream'.Seq1 (Option α))) →
(n : ℕ) →
((x : ℕ) → motive none x) →
((s' : Stream'.Seq (Option α)) → (n : ℕ) → motive (some (none, s')) n) →
((a' : α) → (s' : Stream'.Seq (Option α)) → moti... | null | false |
Std.HashMap.size_inter_le_size_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α],
(m₁ ∩ m₂).size ≤ m₂.size | null | true |
CategoryTheory.Limits.IsImage.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{F : CategoryTheory.Limits.MonoFactorisation f} →
(lift : (F' : CategoryTheory.Limits.MonoFactorisation f) → F.I ⟶ F'.I) →
autoParam
(∀ (F' : CategoryTheory.Limits.MonoFactorisa... | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.Slice.Pattern.Model.revAll_eq_true_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.add.match_1.splitter | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : AddMonoid k] →
(motive : SkewMonoidAlgebra k G → SkewMonoidAlgebra k G → Sort u_3) →
(x x_1 : SkewMonoidAlgebra k G) → ((a b : G →₀ k) → motive { coeff := a } { coeff := b }) → motive x x_1 | null | true |
TopologicalLattice.mk._flat_ctor | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] [inst_1 : Lattice L],
(Continuous fun p => p.1 ⊓ p.2) → (Continuous fun p => p.1 ⊔ p.2) → TopologicalLattice L | null | false |
MeasureTheory.MemLp.smul_measure_nnreal | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε} {c : NNReal}, MeasureTheory.MemLp f p μ → MeasureTheory.MemLp f p (c • μ) | null | true |
MulDistribMulActionHom.map_mul' | 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]
(self : A →ₑ*[φ] B) (x y : A), self.toFun (x * y) = self.toFun x * self.toFun y | The proposition that the function preserves multiplication | true |
UInt8.recOn.eq._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.222 | Mathlib.Util.CompileInductive | @UInt8.recOn = @UInt8.recOn✝ | null | false |
SSet.instIsSmallOfHomsFinHAddNatOfNatιHorn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | ∀ (n : ℕ),
CategoryTheory.MorphismProperty.IsSmall.{u, u, u + 1}
(CategoryTheory.MorphismProperty.ofHoms fun i => (SSet.horn (n + 1) i).ι) | null | true |
Std.Http.Protocol.H1.RedirectOutcome | Std.Http.Protocol.H1.Redirect | Type | Result of evaluating whether to follow a redirect.
| true |
OrderedFinpartition.compAlongOrderedFinpartitionₗ._proof_10 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n) (... | null | false |
Matrix.IsAdjMatrix.toGraphSubmatrixHom._proof_2 | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_2} {V : Type u_3} {W : Type u_1} (A : Matrix V V α) [inst : MulZeroOneClass α] [inst_1 : Nontrivial α]
(h : A.IsAdjMatrix) (f : W → V) {a b : W}, ⋯.toGraph.Adj a b → h.toGraph.Adj (f a) (f b) | null | false |
_private.Init.Data.List.Basic.0.List.zipWith.match_1.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Sort u_3) (x : List α) (x_1 : List β)
(h_1 : (x : α) → (xs : List α) → (y : β) → (ys : List β) → motive (x :: xs) (y :: ys))
(h_2 : (x : List α) → (x_2 : List β) → motive x x_2),
(∀ (x_2 : α) (xs : List α) (y : β) (ys : List β), x = x_2 :: xs → x_1 = y :... | null | true |
Subsemiring.comap_toSubmonoid | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (s : Subsemiring S),
(Subsemiring.comap f s).toSubmonoid = { carrier := ⇑f ⁻¹' ↑s, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
isMin_iff_eq_bot._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsMin a = (a = ⊥) | null | false |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_free_of_surjective.match_1_2 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_3} {M : Type u_2} {N : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] [inst_5 : Module.Free R M] [inst_6 : Module.Finite R M]
(l : M →ₗ[R] N) (b : Module.Basis (Module.Free.ChooseBasisIndex R M) R M) (motive : ↥⋯.toFinset → Pro... | null | false |
CommMonCat.coyonedaType_map_app | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ {X Y : Type uᵒᵖ} (f : X ⟶ Y) (N : CommMonCat),
(CommMonCat.coyonedaType.map f).app N =
CommMonCat.ofHom
(MonoidHom.pi fun i => Pi.evalMonoidHom (fun a => ↑N) ((CategoryTheory.ConcreteCategory.hom f.unop) i)) | null | true |
Specializes.inseparable | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] {x y : X}, x ⤳ y → Inseparable x y | In an R₀ space, `Specializes` implies `Inseparable`. | true |
_private.Batteries.Lean.Expr.0.Lean.Expr.withApp'.go._f | Batteries.Lean.Expr | {α : Sort u_1} →
(Lean.Expr → Array Lean.Expr → α) →
(a : Lean.Expr) → Lean.Expr.below (motive := fun a => Array Lean.Expr → ℕ → α) a → Array Lean.Expr → ℕ → α | null | false |
_private.Mathlib.Analysis.Analytic.Within.0.analyticOn_of_locally_analyticOn._simp_1_7 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
VectorField.pullback_eq_of_fderiv_eq | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{M : E ≃L[𝕜] F} {x : E}, ↑M = fderiv 𝕜 f x → ∀ (V : F → F), VectorField.pullback 𝕜 f V x = M.symm... | null | true |
NNReal.instSemiring._proof_5 | Mathlib.Basic.NNReal.Defs | ∀ (a : NNReal), a + 0 = a | null | false |
_private.Mathlib.NumberTheory.DirichletCharacter.Basic.0.DirichletCharacter.factorsThrough_gcd._simp_1_2 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {α : Type u_1} [inst : Semigroup α] (a b : α), (a ∣ a * b) = True | null | false |
Function.Surjective.iUnion_comp | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {ι : Sort u_4} {ι₂ : Sort u_5} {f : ι → ι₂},
Function.Surjective f → ∀ (g : ι₂ → Set α), ⋃ x, g (f x) = ⋃ y, g y | null | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Ordinal.0.Cardinal.mk_subset_mk_lt_cof._simp_1_1 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b ≤ a) = ¬a < b | null | false |
Lean.Linter.getEnvLinterSnapshotEntry? | Lean.Linter.Init | Lean.Environment → Lean.Name → Lean.Name → Option Bool | null | true |
Filter.add.instNeBot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f g : Filter α} [f.NeBot] [g.NeBot], (f + g).NeBot | null | true |
Polynomial.natDegree_mul_C | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {a : R} [NoZeroDivisors R],
a ≠ 0 → (p * Polynomial.C a).natDegree = p.natDegree | null | true |
GenContFract.contsAux_recurrence | Mathlib.Algebra.ContinuedFractions.ContinuantsRecurrence | ∀ {K : Type u_1} {g : GenContFract K} {n : ℕ} [inst : DivisionRing K] {gp ppred pred : GenContFract.Pair K},
g.s.get? n = some gp →
g.contsAux n = ppred →
g.contsAux (n + 1) = pred →
g.contsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b } | null | true |
AffineSubspace.coe_vsub | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s] (a b : ↥s), ↑(a -ᵥ b) = ↑a -ᵥ ↑b | null | true |
List._sizeOf_1._@.Mathlib.Util.CompileInductive.1590845460._hygCtx._hyg.11 | Mathlib.Util.CompileInductive | {α : Type u} → [SizeOf α] → List α → ℕ | null | false |
Nat.sqrt_le_self | Mathlib.Data.Nat.Sqrt | ∀ (n : ℕ), n.sqrt ≤ n | null | true |
Bundle.Trivialization.pullback._proof_9 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_4} {F : Type u_1} {E : B → Type u_3} {B' : Type u_2} [inst : TopologicalSpace B']
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : TopologicalSpace F] [inst_3 : TopologicalSpace B]
[inst_4 : ∀ (_b : B), Nonempty (E _b)] {K : Type u_5} [inst_5 : FunLike K B' B] [ContinuousMapClass K B' B]
... | null | false |
upperBounds_mono_set | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] ⦃s t : Set α⦄, s ⊆ t → upperBounds t ⊆ upperBounds s | null | true |
StarRingEquiv.mk | Mathlib.Algebra.Star.StarRingHom | {A : Type u_1} →
{B : Type u_2} →
[inst : Add A] →
[inst_1 : Add B] →
[inst_2 : Mul A] →
[inst_3 : Mul B] →
[inst_4 : Star A] →
[inst_5 : Star B] →
(toRingEquiv : A ≃+* B) →
(∀ (a : A), toRingEquiv.toFun (star a) = star (toRingEqu... | null | true |
Differential.ContainConstants.casesOn | Mathlib.RingTheory.Derivation.DifferentialRing | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Differential B] →
{motive : Differential.ContainConstants A B → Sort u} →
(t : Differential.ContainConstants A B) →
((mem_range_of_de... | null | false |
CategoryTheory.AddMod.comap | Mathlib.CategoryTheory.Monoidal.Mod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A B : C} →
[inst_4 : C... | A morphism of additive monoid objects induces a "restriction" or "comap" functor
between the categories of additive module objects. | true |
Std.DTreeMap.Raw.size_le_size_insertMany_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List ((a : α) × β a)}, t.size ≤ (t.insertMany l).size | null | true |
List.isSome_max?_iff | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] {xs : List α}, xs.max?.isSome = true ↔ xs ≠ [] | null | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getUSizePow2Exponent? | Lean.Compiler.LCNF.Simp.ConstantFold | UInt64 → Option UInt64 | If `x` is a power of two with the same exponent in both its 64 and 32 bit
interpretation, return that exponent.
| true |
ContinuousLinearMap.isPositive_natCast._simp_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : ℕ}, (↑n).IsPositive = True | null | false |
Aesop.LIFOQueue.casesOn | Aesop.Search.Queue | {motive : Aesop.LIFOQueue → Sort u} →
(t : Aesop.LIFOQueue) → ((goals : Array Aesop.GoalRef) → motive { goals := goals }) → motive t | null | false |
withBotSucc_zero | Mathlib.Order.SuccPred.Nat | WithBot.succ 0 = 1 | null | true |
Submodule.le_orthogonalBilin_orthogonalBilin | Mathlib.LinearAlgebra.SesquilinearForm.Orthogonal | ∀ {R : Type u_1} {R₁ : Type u_2} {M : Type u_4} {M₁ : Type u_5} [inst : CommSemiring R] [inst_1 : CommSemiring R₁]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : AddCommMonoid M₁] [inst_5 : Module R₁ M₁] {I₁ : R₁ →+* R}
{S : Submodule R₁ M₁} {I₂ : R₁ →+* R} {B : M₁ →ₛₗ[I₁] M₁ →ₛₗ[I₂] M},
B.IsRefl → S ... | null | true |
_private.Mathlib.Topology.Constructions.0.Topology.isOpenEmbedding_sigmaMap._simp_1_2 | Mathlib.Topology.Constructions | ∀ {ι : Type u_2} {κ : Type u_3} {σ : ι → Type u_4} {τ : κ → Type u_5} [inst : (i : ι) → TopologicalSpace (σ i)]
[inst_1 : (k : κ) → TopologicalSpace (τ k)] {f₁ : ι → κ} {f₂ : (i : ι) → σ i → τ (f₁ i)},
IsOpenMap (Sigma.map f₁ f₂) = ∀ (i : ι), IsOpenMap (f₂ i) | null | false |
Monoid.toMulAction._proof_1 | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_1) [inst : Monoid M] (a b c : M), a * b * c = a * (b * c) | null | false |
CategoryTheory.Limits.Cone.mk.noConfusion | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} J} →
{C : Type u₃} →
{inst_1 : CategoryTheory.Category.{v₃, u₃} C} →
{F : CategoryTheory.Functor J C} →
{P : Sort u} →
{pt : C} →
{π : (CategoryTheory.Functor.const J).obj pt ⟶ F} →
{pt' : C}... | null | false |
AlgebraicGeometry.instSurjectiveOfGeometricallyIrreducible | Mathlib.AlgebraicGeometry.Geometrically.Irreducible | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) [AlgebraicGeometry.GeometricallyIrreducible f],
AlgebraicGeometry.Surjective f | null | true |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.dollarSyntax.dollarSyntaxLinter | Mathlib.Tactic.Linter.Style | Lean.Linter | The `dollarSyntax` linter flags uses of `<|` that are achieved by typing `$`.
These are disallowed by the mathlib style guide, as using `<|` pairs better with `|>`. | true |
_private.Init.Data.Dyadic.Basic.0.Dyadic.add.match_3.eq_2 | Init.Data.Dyadic.Basic | ∀ (motive : Dyadic → Dyadic → Sort u_1) (x : Dyadic) (h_1 : (y : Dyadic) → motive Dyadic.zero y)
(h_2 : (x : Dyadic) → motive x Dyadic.zero)
(h_3 :
(n₁ k₁ : ℤ) →
(hn₁ : n₁ % 2 = 1) → (n₂ k₂ : ℤ) → (hn₂ : n₂ % 2 = 1) → motive (Dyadic.ofOdd n₁ k₁ hn₁) (Dyadic.ofOdd n₂ k₂ hn₂)),
(x = Dyadic.zero → False) →... | null | true |
CoxeterMatrix.E₆._proof_1 | Mathlib.GroupTheory.Coxeter.Matrix | !![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1].IsSymm | null | false |
Lean.Parser.Tactic.symm | Init.Tactics | Lean.ParserDescr | * `symm` applies to a goal whose target has the form `t ~ u` where `~` is a symmetric relation,
that is, a relation which has a symmetry lemma tagged with the attribute [symm].
It replaces the target with `u ~ t`.
* `symm at h` will rewrite a hypothesis `h : t ~ u` to `h : u ~ t`.
| true |
MeasureTheory.lintegral_eq_nnreal | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} (f : α → ENNReal) (μ : MeasureTheory.Measure α),
∫⁻ (a : α), f a ∂μ =
⨆ φ, ⨆ (_ : ∀ (x : α), ↑(φ x) ≤ f x), (MeasureTheory.SimpleFunc.map ENNReal.ofNNReal φ).lintegral μ | `∫⁻ a in s, f a ∂μ` is defined as the supremum of integrals of simple functions
`φ : α →ₛ ℝ≥0∞` such that `φ ≤ f`. This lemma says that it suffices to take
functions `φ : α →ₛ ℝ≥0`. | true |
_private.Mathlib.RingTheory.Jacobson.Ring.0.isJacobsonRing_localization.match_1_1 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (y : R) [inst_2 : Algebra R S] (P' : Ideal S)
(I : Ideal R) (motive : I ∈ {I | Ideal.comap (algebraMap R S) P' ≤ I ∧ I.IsMaximal ∧ y ∉ I} → Prop)
(x : I ∈ {I | Ideal.comap (algebraMap R S) P' ≤ I ∧ I.IsMaximal ∧ y ∉ I}),
(∀ (hI : Ideal.coma... | null | false |
MeasureTheory.Measure.sub_mem_nhds_zero_of_addHaar_pos | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] (μ : MeasureTheory.Measure G) [μ.IsAddHaarMeasure] [LocallyCompactSpace G]
[μ.InnerRegular] (E : Set G), MeasurableSet E → 0 < μ E → E - E ∈ nhds 0 | **Steinhaus Theorem**.
In any locally compact group `G` with an inner regular Haar measure `μ`,
for any measurable set `E` of positive measure, the set `E - E` is a neighbourhood of `0`. | true |
ContinuousLinearMap.coe_injective | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂],
Function.Injective ... | null | true |
_private.Mathlib.Order.SetNotation.0.iSup_delab.match_1 | Mathlib.Order.SetNotation | (motive : Array Lean.Expr → Sort u_1) →
(x : Array Lean.Expr) →
((head ι head_1 f : Lean.Expr) → motive #[head, ι, head_1, f]) → ((x : Array Lean.Expr) → motive x) → motive x | null | false |
HomogeneousIdeal.ext_iff | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] [inst_5 : GradedRing 𝒜]
{I J : HomogeneousIdeal 𝒜}, I = J ↔ I.toIdeal = J.toIdeal | null | true |
CategoryTheory.SplitEpi.comp | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y Z : C} →
{f : X ⟶ Y} →
{g : Y ⟶ Z} →
CategoryTheory.SplitEpi f →
CategoryTheory.SplitEpi g → CategoryTheory.SplitEpi (CategoryTheory.CategoryStruct.comp f g) | A composition of `SplitEpi` is a split `SplitEpi`. | true |
IsLocalRing.primesOver_eq | Mathlib.RingTheory.DedekindDomain.Basic | ∀ {R : Type u_1} (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsLocalRing A] [IsDedekindDomain A]
[inst_4 : Algebra R A] [FaithfulSMul R A] [Module.Finite R A] {p : Ideal R} [p.IsMaximal],
p ≠ ⊥ → p.primesOver A = {IsLocalRing.maximalIdeal A} | null | true |
Monotone.relComp | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_6} [inst : Preorder ι] {f : ι → SetRel α β}
{g : ι → SetRel β γ}, Monotone f → Monotone g → Monotone fun x => (f x).comp (g x) | null | true |
_private.Mathlib.Data.Set.Lattice.Indexed.0.Set.iInter_mono'.match_1_1 | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_2} {ι : Sort u_1} {ι' : Sort u_3} {s : ι → Set α} {t : ι' → Set α} (j : ι')
(motive : (∃ i, s i ⊆ t j) → Prop) (x : ∃ i, s i ⊆ t j), (∀ (i : ι) (hi : s i ⊆ t j), motive ⋯) → motive x | null | false |
instIsScalarTowerPolynomial | Mathlib.RingTheory.PolynomialAlgebra | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : Algebra R S] [inst_5 : Algebra S A] [IsScalarTower R S A],
IsScalarTower R (Polynomial S) (Polynomial A) | null | true |
Std.DTreeMap.Internal.Impl.Const.get?_eq_none_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF → ∀ {a : α}, Std.DTreeMap.Internal.Impl.contains a t = false → Std.DTreeMap.Internal.Impl.Const.get? t a = none | null | true |
CategoryTheory.ComonObj.counit | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} → [self : CategoryTheory.ComonObj X] → X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C | The counit morphism of a comonoid object. | true |
ImportGraph.Shake.Needs.sub | ImportGraph.Shake.Core | ImportGraph.Shake.Needs → ImportGraph.Shake.NeedsKind → ImportGraph.Shake.Bitset → ImportGraph.Shake.Needs | null | true |
Lean.ErrorExplanation.doc | Lean.ErrorExplanation | Lean.ErrorExplanation → String | The `doc` field is deprecated and should always be the empty string | true |
SMulMemClass.ofIsScalarTower | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ (S : Type u_1) (M : Type u_2) (N : Type u_3) (α : Type u_4) [inst : SetLike S α] [inst_1 : SMul M N]
[inst_2 : SMul M α] [inst_3 : Monoid N] [inst_4 : MulAction N α] [SMulMemClass S N α] [IsScalarTower M N α],
SMulMemClass S M α | This can't be an instance because Lean wouldn't know how to find `N`, but we can still use
this to manually derive `SMulMemClass` on specific types. | true |
IsOrderBornology.cobounded_eq_atTop | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} [inst : Bornology α] [inst_1 : LinearOrder α] [IsOrderBornology α] [NoMaxOrder α] [OrderBot α],
Bornology.cobounded α = Filter.atTop | null | true |
Std.Rio.eq_succMany?_of_toArray_eq_append_append._proof_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Rio α} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[inst_5 : Std.Rxo.IsAlwaysFinite α] {pref suff : Array α} {cur : α},
r.toArray = pref ++ #[cur] ++ suff → pref.size < r.toA... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.