name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ImportGraph.Shake.instReprBitset | ImportGraph.Shake.Core | Repr ImportGraph.Shake.Bitset | null | true |
Std.Internal.instPureForIn'RciOfLawfulMonad | Std.Internal.ForIn.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxi.IsAlwaysFinite α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α] {m : Type u → Type v}
[inst_5 : Monad m] [LawfulMonad m], Std.Internal.PureForIn' m (Std.Rci α) α | null | true |
CategoryTheory.ShiftedHom.opEquiv' | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
{X Y : C} →
(n a a' : ℤ) →
n + a = a' →
CategoryTheory.ShiftedHom X Y a' ≃
(Opposite.op ((CategoryTheory.shiftFunctor C a).obj Y) ⟶
(CategoryT... | The bijection `ShiftedHom X Y a' ≃ (Opposite.op (Y⟦a⟧) ⟶ (Opposite.op X)⟦n⟧)`
when integers `n`, `a` and `a'` satisfy `n + a = a'`, and `X` and `Y` are objects
of a category equipped with a shift by `ℤ`. | true |
Std.DTreeMap.Internal.Impl.get?.match_1.congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Sort u} {o o' : Ordering} {lt : o = Ordering.lt → α} {eq : o = Ordering.eq → α} {gt : o = Ordering.gt → α}
{lt' : o' = Ordering.lt → α} {eq' : o' = Ordering.eq → α} {gt' : o' = Ordering.gt → α} (ho : o = o'),
(∀ (h : o' = Ordering.lt), lt ⋯ = lt' h) →
(∀ (h : o' = Ordering.eq), eq ⋯ = eq' h) →
(∀ (... | null | true |
RingEquiv.ringKrullDim | Mathlib.RingTheory.KrullDimension.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (e : R ≃+* S),
ringKrullDim R = ringKrullDim S | **Alias** of `ringKrullDim_eq_of_ringEquiv`.
---
If `R` and `S` are isomorphic, then `ringKrullDim R = ringKrullDim S`. | true |
CochainComplex.HomComplex.Cochain.fromSingleMk.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f f_1 : X ⟶ K.X q),
f = f_1 →
∀ {n : ℤ} (x : p + n = q) (T : CochainComplex.HomComplex.Triplet n),
CochainComplex.Ho... | null | true |
Lean.Order.MonadTail.noConfusion | Init.Internal.Order.MonadTail | {P : Sort u_1} →
{m : Type u → Type v} →
{inst : Bind m} →
{t : Lean.Order.MonadTail m} →
{m' : Type u → Type v} →
{inst' : Bind m'} →
{t' : Lean.Order.MonadTail m'} →
m = m' → inst ≍ inst' → t ≍ t' → Lean.Order.MonadTail.noConfusionType P t t' | null | false |
_private.Mathlib.Probability.Decision.Risk.Defs.0.ProbabilityTheory.bayesRisk_of_isEmpty'._simp_1_1 | Mathlib.Probability.Decision.Risk.Defs | ∀ {α : Sort u_1} (p : α → Prop), IsEmpty (Subtype p) = ∀ (x : α), ¬p x | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalNNRealRpow.match_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
Option Q(PartialOrder «$α») →
(e : Q(«$α»)) →
(val : Q(PartialOrder «$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x e (some val)) →
Lean.MetaM (Mathlib.Me... | null | false |
_private.Batteries.Lean.EStateM.0.EStateM.bind.match_1.splitter | Batteries.Lean.EStateM | {ε σ α : Type u_1} →
(motive : EStateM.Result ε σ α → Sort u_2) →
(x : EStateM.Result ε σ α) →
((a : α) → (s : σ) → motive (EStateM.Result.ok a s)) →
((e : ε) → (s : σ) → motive (EStateM.Result.error e s)) → motive x | null | true |
Substring.Raw.Valid.drop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∀ (n : ℕ), (s.drop n).Valid | null | true |
LocallyConstant.coe_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (y : Y), ⇑(LocallyConstant.const X y) = Function.const X y | null | true |
AffineSubspace.coe_direction_eq_vsub_set_right | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {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} {p : P}, p ∈ s → ↑s.direction = (fun x => x -ᵥ p) '' ↑s | Given a point in an affine subspace, the set of vectors in its direction equals the set of
vectors subtracting that point on the right. | true |
ImportGraph.Lake.BaseLibrary.roots._default | ImportGraph.WorkspaceModel.Base | Lean.Name → Array Lean.Name | null | false |
EckmannHilton.IsUnital | Mathlib.GroupTheory.EckmannHilton | {X : Type u} → (X → X → X) → X → Prop | `IsUnital m e` expresses that `e : X` is a left and right unit
for the binary operation `m : X → X → X`. | true |
AlgebraicGeometry.instUniversallyClosedToImage | Mathlib.AlgebraicGeometry.Morphisms.Proper | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.UniversallyClosed f],
AlgebraicGeometry.UniversallyClosed (AlgebraicGeometry.Scheme.Hom.toImage f) | null | true |
LocallyBoundedMap.instFunLike._proof_1 | Mathlib.Topology.Bornology.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Bornology α] [inst_1 : Bornology β] (f g : LocallyBoundedMap α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
RootPairing.GeckConstruction.ωConj | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | {ι : 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} →
... | The conjugation `x ↦ ωxω` as an equivalence of Lie algebras. | true |
Lean.Elab.Term.Quotation.match_syntax.expand | Lean.Elab.Quotation | Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax | null | true |
_private.Mathlib.Computability.DFA.0.DFA.acceptsFrom_inter._simp_1_2 | Mathlib.Computability.DFA | ∀ {α : Type u_1} {x : List α} {l m : Language α}, (x ∈ l ⊓ m) = (x ∈ l ∧ x ∈ m) | null | false |
Lean.Compiler.LCNF.Decl.lambdaLifting | Lean.Compiler.LCNF.LambdaLifting | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Bool →
Bool →
Lean.Name →
optParam Bool false →
optParam ℕ 0 → Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) | null | true |
PartOrdEmb.coe_comp | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y Z : PartOrdEmb} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors.0.UniqueFactorizationMonoid.normalizedFactorsEquiv._simp_3 | Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] {x : M} [inst_2 : EquivLike F M N]
[MulEquivClass F M N] (f : F), Irreducible (f x) = Irreducible x | null | false |
Turing.Dir.right | Mathlib.Computability.TuringMachine.Tape | Turing.Dir | null | true |
_private.Mathlib.Order.CompleteBooleanAlgebra.0.sSup_disjoint_iff._simp_1_2 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (iSup s = ⊥) = ∀ (i : ι), s i = ⊥ | null | false |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_sUnion_le.match_1_3 | Mathlib.SetTheory.ZFC.Rank | ∀ (x : PSet.{u_1}) ⦃y : PSet.{u_1}⦄ (motive : (∃ z ∈ x, y ∈ z) → Prop) (h : ∃ z ∈ x, y ∈ z),
(∀ (w : PSet.{u_1}) (left : w ∈ x) (right : y ∈ w), motive ⋯) → motive h | null | false |
Ring.DirectLimit.hom_ext | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] {g₁ g₂ : Ring.DirectLimit G f →+* P},
(∀ (i : ι), g₁.comp (Ring.DirectLimit.of G f i) = g₂.comp (Ring.DirectLimit.of G f i)) → g₁ = g₂ | null | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.Term.listDecode_encode_list._simp_1_9 | Mathlib.ModelTheory.Encoding | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
_private.Mathlib.CategoryTheory.Comma.StructuredArrow.Small.0.CategoryTheory.StructuredArrow.small_inverseImage_proj_of_locallySmall._simp_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Small | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C) (Y : C),
CategoryTheory.ObjectProperty.ofObj X Y = ∃ i, X i = Y | null | false |
CoeHTCT.mk.noConfusion | Init.Coe | {α : Sort u} →
{β : Sort v} → {P : Sort u_1} → {coe coe' : α → β} → { coe := coe } = { coe := coe' } → (coe ≍ coe' → P) → P | null | false |
CategoryTheory.MonadicRightAdjoint.recOn | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
{motive : CategoryTheory.MonadicRightAdjoint R → Sort u} →
(t : CategoryTheory.MonadicRightAdjoint R) →
... | null | false |
CentroidHom.instRing._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α], SMulCommClass ℕ α α | null | false |
Mathlib.Tactic.Ring.Common.const_pos | Mathlib.Tactic.Ring.Common | ∀ (n : ℕ), Nat.ble 1 n = true → 0 < n.rawCast | null | true |
LieRing.ofAssociativeRing | Mathlib.Algebra.Lie.OfAssociative | {A : Type v} → [Ring A] → LieRing A | An associative ring gives rise to a Lie ring by taking the bracket to be the ring commutator. | true |
TensorProduct.finsuppRight | Mathlib.LinearAlgebra.DirectSum.Finsupp | (R : Type u_1) →
(S : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : Semiring S] →
[inst_2 : Algebra R S] →
(M : Type u_3) →
[inst_3 : AddCommMonoid M] →
[inst_4 : Module R M] →
[inst_5 : Module S M] →
[inst_6 : IsScalarTower R S... | The tensor product of `M` and `ι →₀ N` is linearly equivalent to `ι →₀ M ⊗[R] N` | true |
CategoryTheory.ShortComplex.isColimitColimitCocone | Mathlib.Algebra.Homology.ShortComplex.Limits | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)) →
[inst_3 : CategoryTheory.Li... | `colimitCocone F` is colimit. | true |
Mathlib.Command.MinImports.getSyntaxNodeKinds._unsafe_rec | Mathlib.Tactic.MinImports | Lean.Syntax → Lean.NameSet | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.RootPositiveForm.rootLength_le_of_pairingIn_eq._proof_1_6 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_6 : CharZero R], FaithfulSMul ℤ R | null | false |
Aesop.instInhabitedGoalId.default | Aesop.Tree.Data | Aesop.GoalId | null | true |
Lean.Parser.getAlias | Lean.Parser.Extension | {α : Type} → IO.Ref (Lean.Parser.AliasTable α) → Lean.Name → IO (Option (Lean.Parser.AliasValue α)) | null | true |
Lean.Data.AC.ContextInformation.mk | Init.Data.AC | {α : Sort u} → (α → ℕ → Bool) → (α → Bool) → (α → Bool) → Lean.Data.AC.ContextInformation α | null | true |
Filter.cardinalInterFilter_sup | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} (l₁ l₂ : Filter α) {c₁ c₂ : Cardinal.{u}} [CardinalInterFilter l₁ c₁] [CardinalInterFilter l₂ c₂],
CardinalInterFilter (l₁ ⊔ l₂) (min c₁ c₂) | null | true |
ContDiffWithinAt.mono | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, ContDiffWithinAt 𝕜 n f s x → ∀ {t : Set E}, t ⊆ s → ContDiffWithi... | null | true |
Qq.Impl.mkNAryFunctionType._unsafe_rec | Qq.Match | ℕ → Lean.MetaM Lean.Expr | null | false |
CategoryTheory.Comma.fstSndJointlyReflectColimit._proof_4 | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {A : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} A] {B : Type u_8} [inst_2 : CategoryTheory.Category.{u_7, u_8} B]
{T : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} T] {L : CategoryTheory.Functor A T}
{R : CategoryTheory.Functor B... | null | false |
FormalGroup.𝔾ₐ._proof_3 | Mathlib.RingTheory.FormalGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R], (MvPowerSeries.coeff fun₀ | 1 => 1) (MvPowerSeries.X 0 + MvPowerSeries.X 1) = 1 | null | false |
_private.Mathlib.Analysis.SpecificLimits.Basic.0.tendsto_nat_floor_atTop._simp_1_1 | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : FloorSemiring α] {a : α} {n : ℕ},
0 ≤ a → (n ≤ ⌊a⌋₊) = (↑n ≤ a) | null | false |
CategoryTheory.MonadIso.toNatIso | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → {M N : CategoryTheory.Monad C} → (M ≅ N) → (M.toFunctor ≅ N.toFunctor) | An isomorphism of monads gives a natural isomorphism of the underlying functors.
| true |
TopModuleCat.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | Sort u_1 →
{R : Type u} →
[inst : Ring R] →
[inst_1 : TopologicalSpace R] →
TopModuleCat R →
{R' : Type u} → [inst' : Ring R'] → [inst'_1 : TopologicalSpace R'] → TopModuleCat R' → Sort u_1 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Finite.0.SimpleGraph.odd_ncard_oddComponents._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Finite | ∀ {α : Type u_1} (s : Set α) [inst : Fintype ↑s], s.toFinset.card = s.ncard | null | false |
imaginaryPart_smul | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : AddCommGroup A] [inst_1 : Module ℂ A] [inst_2 : StarAddMonoid A] [inst_3 : StarModule ℂ A]
(z : ℂ) (a : A), imaginaryPart (z • a) = z.re • imaginaryPart a + z.im • realPart a | null | true |
Quiver.rec | Mathlib.Combinatorics.Quiver.Basic | {V : Type u} →
{motive : Quiver V → Sort u_1} → ((Hom : V → V → Type v) → motive { Hom := Hom }) → (t : Quiver V) → motive t | null | false |
AddSemigroupAction.mk | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} →
{P : Type u_10} →
[inst : AddSemigroup G] →
[toVAdd : VAdd G P] → (∀ (g₁ g₂ : G) (p : P), (g₁ + g₂) +ᵥ p = g₁ +ᵥ g₂ +ᵥ p) → AddSemigroupAction G P | null | true |
List.range'_one | Init.Data.List.Basic | ∀ {s step : ℕ}, List.range' s 1 step = [s] | null | true |
InnerProductSpace.Core.inner_self_eq_norm_mul_norm | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), RCLike.re (inner 𝕜 x x) = ‖x‖ * ‖x‖ | null | true |
Matroid.isColoop_iff_mem_coloops | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsColoop e ↔ e ∈ M.coloops | null | true |
_private.Mathlib.Basic.Real.ConjExponents.0.ENNReal.HolderConjugate.toNNReal_iff._simp_1_2 | Mathlib.Basic.Real.ConjExponents | ∀ (z : ENNReal), z.toReal = ↑z.toNNReal | null | false |
Aesop.incrementIteration | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q Unit | null | true |
Std.Time.Week.instLEOffset._aux_1 | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Week.Offset → Prop | null | false |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map_comp | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : Type u} [inst_1 : LinearOrder J]
[inst_2 : SuccOrder J] {j : J} (hj : ¬IsMax j) (F : CategoryTheory.Functor (↑(Set.Iic j)) C) {X : C}
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) (i₁ i₂ i₃ : J) (h₁₂ : i₁ ≤ i₂) (h₂₃ : i₂ ≤ i₃) (h : i₃ ≤ Order.succ j),
CategoryTheory.Sm... | null | true |
Metric.exists_continuous_real_forall_closedEBall_subset | Mathlib.Topology.MetricSpace.PartitionOfUnity | ∀ {ι : Type u_1} {X : Type u_2} [inst : EMetricSpace X] {K U : ι → Set X},
(∀ (i : ι), IsClosed (K i)) →
(∀ (i : ι), IsOpen (U i)) →
(∀ (i : ι), K i ⊆ U i) →
LocallyFinite K →
∃ δ, (∀ (x : X), 0 < δ x) ∧ ∀ (i : ι), ∀ x ∈ K i, Metric.closedEBall x (ENNReal.ofReal (δ x)) ⊆ U i | Let `X` be an extended metric space. Let `K : ι → Set X` be a locally finite family of closed
sets, let `U : ι → Set X` be a family of open sets such that `K i ⊆ U i` for all `i`. Then there
exists a positive continuous function `δ : C(X, ℝ)` such that for any `i` and `x ∈ K i`,
we have `Metric.closedEBall x (ENNReal.o... | true |
Complex.UnitDisc.coe_mul._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z w : Complex.UnitDisc), ↑z * ↑w = ↑(z * w) | null | false |
Lake.SemVerCore.instLE | Lake.Util.Version | LE Lake.SemVerCore | null | true |
SimpleGraph.Walk.concat_dropLast | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (hp : G.Adj p.penultimate v), p.dropLast.concat hp = p | null | true |
Dioph.reindex_dioph | Mathlib.NumberTheory.Dioph | ∀ {α : Type u} (β : Type u) {S : Set (α → ℕ)} (f : α → β), Dioph S → Dioph {v | v ∘ f ∈ S} | null | true |
NontriviallyNormedField.ofNormNeOne | Mathlib.Analysis.Normed.Field.Basic | {𝕜 : Type u_3} → [h' : NormedField 𝕜] → (∃ x, x ≠ 0 ∧ ‖x‖ ≠ 1) → NontriviallyNormedField 𝕜 | A normed field is nontrivially normed
provided that the norm of some nonzero element is not one. | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.evalSpecialize.match_1 | Lean.Elab.Tactic.ElabTerm | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
Mathlib.Tactic.Linarith.leftOfIneqProof | Mathlib.Tactic.Linarith.Verification | Lean.Expr → Lean.MetaM Lean.Expr | If `prf` is a proof of `t R s`, `leftOfIneqProof prf` returns `t`. | true |
alternatingGroup.iwasawaStructure_three._proof_4 | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (g : ↥(alternatingGroup α)) (s : ↑(Set.powersetCard α 3)),
(alternatingGroup.ofSubtype (g • ↑s)).range = MulAut.conj g • (alternatingGroup.ofSubtype ↑s).range | null | false |
CategoryTheory.Presieve.HasPairwisePullbacks.mk | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R : CategoryTheory.Presieve X},
(∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → CategoryTheory.Limits.HasPullback f g) → R.HasPairwisePullbacks | null | true |
tendsto_indicator_thickening_indicator_closure | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {β : Type u_2} [inst_1 : Zero β] [inst_2 : TopologicalSpace β]
(f : α → β) (E : Set α),
Filter.Tendsto (fun δ => (Metric.thickening δ E).indicator f) (nhdsWithin 0 (Set.Ioi 0))
(nhds ((closure E).indicator f)) | The indicators of δ-thickenings of a set tend pointwise to the indicator of the
set, as δ>0 tends to zero. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insert_le_minKey?._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Valuation.ofAddValuation._proof_4 | Mathlib.RingTheory.Valuation.Basic | ∀ {Γ₀ : Type u_1} [inst : LinearOrderedCommMonoidWithZero Γ₀] {a b : Multiplicative (Additive Γ₀)ᵒᵈᵒᵈ},
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd a))) ≤
Additive.toMul (OrderDual.ofDual (OrderDual.ofDual (Multiplicative.toAdd b))) ↔
Additive.toMul (OrderDual.ofDual (OrderDual.... | null | false |
Set.centralizer.eq_1 | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} (S : Set M) [inst : Mul M], S.centralizer = {c | ∀ m ∈ S, m * c = c * m} | null | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushAllArgs._unsafe_rec | Lean.Meta.Sym.Simp.DiscrTree | Lean.Expr → Array Lean.Expr → Array Lean.Expr | null | false |
_private.Mathlib.Data.List.Chain.0.List.IsChain.rel_getLast_head_of_append.match_1_1 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} (motive : (l₁ l₂ : List α) → List.IsChain R (l₁ ++ l₂) → l₁ ≠ [] → l₂ ≠ [] → Prop)
(l₁ l₂ : List α) (h : List.IsChain R (l₁ ++ l₂)) (h₁ : l₁ ≠ []) (h₂ : l₂ ≠ []),
(∀ (head head_1 : α) (tail : List α) (h : List.IsChain R ([head] ++ head_1 :: tail)) (h₁ : [head] ≠ [])
(h₂ : h... | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Icc_div._proof_1_7 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n : ℕ} {a b : Fin n} (x : ℕ), ↑a ≤ x ∧ x ≤ ↑b → x.succ < n.succ | null | false |
CategoryTheory.ObjectProperty.isColocal_iff_isIso | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) {X Y : C}
(f : X ⟶ Y), P X → P Y → (P.isColocal f ↔ CategoryTheory.IsIso f) | null | true |
_private.Batteries.Linter.UnreachableTactic.0.Batteries.Linter.UnreachableTactic.getTactics._sparseCasesOn_1 | Batteries.Linter.UnreachableTactic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.traverse._proof_1 | Mathlib.Data.Vector.Basic | ∀ {n : ℕ} {F : Type u_1 → Type u_1} {α β : Type u_1} (v : List α),
v.length = n → F (List.Vector β v.length) = F (List.Vector β n) | null | false |
SeminormedGroup.toUniformSpace._inherited_default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
(dist : E → E → ℝ) →
(∀ (x : E), dist x x = 0) →
(∀ (x y : E), dist x y = dist y x) → (∀ (x y z : E), dist x z ≤ dist x y + dist y z) → UniformSpace E | null | false |
Mathlib.Tactic.Push.instBEqHead | Mathlib.Tactic.Push.Attr | BEq Mathlib.Tactic.Push.Head | null | true |
CategoryTheory.PreZeroHypercover.instUniqueI₀Singleton | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S T : C} → (f : S ⟶ T) → Unique (CategoryTheory.PreZeroHypercover.singleton f).I₀ | null | true |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjectiveOnStalks_iff_forall_maximal._simp_1_1 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} (P : Ideal S)
[inst_2 : P.IsPrime],
Function.Surjective ⇑(Localization.localRingHom (Ideal.comap f P) P f ⋯) =
∀ (s : S), ∃ x r, ∃ c ∉ P, f r ∉ P ∧ c * f r * s = c * f x | null | false |
Std.Sat.AIG.rec | Std.Sat.AIG.Basic | {α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{motive : Std.Sat.AIG α → Sort u} →
((decls : Array (Std.Sat.AIG.Decl α)) →
(cache : Std.Sat.AIG.Cache α decls) →
(hdag : Std.Sat.AIG.IsDAG α decls) →
(hzero : 0 < decls.size) →
... | null | false |
Representation.freeLift_toLinearMap | Mathlib.RepresentationTheory.Equiv | ∀ {G : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : AddCommMonoid V] {k : Type u_6} [inst_2 : CommSemiring k]
[inst_3 : Module k V] (σ : Representation k G V) {α : Type u_7} (f : α → V),
(σ.freeLift f).toLinearMap =
(Finsupp.linearCombination k fun x => (σ x.2) (f x.1)) ∘ₗ
↑(Finsupp.curryLinearEqu... | null | true |
dite_dite_distrib_left | Mathlib.Basic.Logic.Lemmas | ∀ {α : Sort u_1} {p q : Prop} [inst : Decidable p] [inst_1 : Decidable q] {a : p → α} {b : ¬p → q → α}
{c : ¬p → ¬q → α},
(dite p a fun hp => dite q (b hp) (c hp)) = if hq : q then dite p a fun hp => b hp hq else dite p a fun hp => c hp hq | null | true |
CategoryTheory.Limits.colimitQuotientCoproduct_epi | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
[inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v, u} C] (F : CategoryTheory.Functor J C),
CategoryTheory.Epi (CategoryTheory.Limits.colimitQuotientCoproduct F) | null | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.carrier.asIdeal.prime.match_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : SetLike σ A] {𝒜 : ℕ → σ} {y : A} (motive : SetLike.IsHomogeneousElem 𝒜 y → Prop)
(x : SetLike.IsHomogeneousElem 𝒜 y), (∀ (ny : ℕ) (hny : y ∈ 𝒜 ny), motive ⋯) → motive x | null | false |
Std.Iter.isSome_atIdxSlow?_repeat | Std.Data.Iterators.Lemmas.Producers.Repeat | ∀ {α : Type w} {f : α → α} {init : α} {k : ℕ}, (Std.Iter.atIdxSlow? k (Std.Iter.repeat f init)).isSome = true | null | true |
CategoryTheory.MorphismProperty.HasOfPostcompProperty.mk | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W W' : CategoryTheory.MorphismProperty C},
(∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), W' g → W (CategoryTheory.CategoryStruct.comp f g) → W f) →
W.HasOfPostcompProperty W' | null | true |
StarAlgHom.toNonUnitalStarAlgHom._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (f : A →⋆ₐ[R] B) (c : R) (x : A),
f (c • x) = c • f x | null | false |
Set.Nontrivial.preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set β}, s.Nontrivial → Function.Surjective f → (f ⁻¹' s).Nontrivial | The preimage of a nontrivial set under a surjective map is nontrivial. | true |
tsub_tsub_le_tsub_add | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] [AddLeftMono α]
{a b c : α}, a - (b - c) ≤ a - b + c | null | true |
ProofWidgets.Jsx.proofWidgetsJsxAttrVal_ | ProofWidgets.Data.Html | Lean.ParserDescr | null | true |
CategoryTheory.Limits.Types.instHasImageMapsType | Mathlib.CategoryTheory.Limits.Types.Images | CategoryTheory.Limits.HasImageMaps (Type u) | null | true |
Std.TreeMap.instEmptyCollection | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → EmptyCollection (Std.TreeMap α β cmp) | null | true |
div_div_div_cancel_left | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : CommGroup G] (a b c : G), c / a / (c / b) = b / a | null | true |
Lean.IR.LocalContextEntry.param.injEq | Lean.Compiler.IR.Basic | ∀ (a a_1 : Lean.IR.IRType), (Lean.IR.LocalContextEntry.param a = Lean.IR.LocalContextEntry.param a_1) = (a = a_1) | null | true |
Std.Iter.Equiv.foldM_eq | Std.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α₁ α₂ β γ : Type w} {m : Type w → Type w'} [Std.Iterator α₁ Id β] [Std.Iterator α₂ Id β]
[inst : Std.Iterator α₁ Id β] [inst_1 : Std.Iterator α₂ Id β] [Std.Iterators.Finite α₁ Id]
[Std.Iterators.Finite α₂ Id] [inst_4 : Monad m] [LawfulMonad m] [inst_6 : Std.IteratorLoop α₁ Id m]
[Std.LawfulIteratorLoop α₁ Id m... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.