name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
sign_nonneg_iff._simp_1 | Mathlib.Data.Sign.Defs | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a : α}, (0 ≤ SignType.sign a) = (0 ≤ a) | null | false |
Lean.LocalDecl.binderInfo | Lean.LocalContext | Lean.LocalDecl → Lean.BinderInfo | null | true |
Codisjoint.eq_top_of_le | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderTop α] {a b : α}, Codisjoint a b → b ≤ a → a = ⊤ | null | true |
Array.find?_range_eq_some._simp_1 | Init.Data.Array.Range | ∀ {n i : ℕ} {p : ℕ → Bool},
(Array.find? p (Array.range n) = some i) = (p i = true ∧ i ∈ Array.range n ∧ ∀ j < i, (!p j) = true) | null | false |
CategoryTheory.NatTrans.IsMonoidal.hcomp | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {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 D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E]
... | null | true |
MeasureTheory.locallyIntegrable_of_norm_le_rpow | Mathlib.Analysis.SpecialFunctions.Pow.Integral | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [BorelSpace E] [inst_5 : NormedAddCommGroup F] {μ : MeasureTheory.Measure E}
[μ.IsAddHaarMeasure],
1 ≤ Module.finrank ℝ E →
∀ {f : E → F} {C α : ℝ},
α < ↑(Module.... | A function that is dominated by `‖x‖ ^ (-d + ε)` is locally integrable | true |
Aesop.Script.LazyStep.postGoals | Aesop.Script.Step | Aesop.Script.LazyStep → Array Lean.MVarId | null | true |
ContinuousMap.instSemigroupWithZeroOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemigroupWithZero β] → [ContinuousMul β] → SemigroupWithZero C(α, β) | null | true |
Char.notLTTrans | Init.Data.Char.Lemmas | Trans (fun x1 x2 => ¬x1 < x2) (fun x1 x2 => ¬x1 < x2) fun x1 x2 => ¬x1 < x2 | null | true |
IsLocalizedModule.map_surjective._simp_1 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] {N : Type u_6} {N' : Type u_7} [inst_6 : AddCommMonoid N] [inst_7 : AddCommM... | null | false |
IsPrimitiveRoot.integralPowerBasisOfPrimePow.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p k : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[inst_2 : IsCyclotomicExtension {p ^ k} ℚ K] (hζ : IsPrimitiveRoot ζ (p ^ k)),
hζ.integralPowerBasisOfPrimePow = (Algebra.adjoin.powerBasis' ⋯).map hζ.adjoinEquivRingOfIntegersOfPrimePow | null | true |
_private.Init.Data.Int.Order.0.Int.sign_sign.match_1_1 | Init.Data.Int.Order | ∀ (motive : ℤ → Prop) (x : ℤ),
(∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive (Int.ofNat n.succ)) → (∀ (a : ℕ), motive (Int.negSucc a)) → motive x | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.id.match_1.eq_1 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithTerminal C → Sort u_2) (a : C)
(h_1 : (a : C) → motive (CategoryTheory.WithTerminal.of a)) (h_2 : Unit → motive CategoryTheory.WithTerminal.star),
(match CategoryTheory.WithTerminal.of a with
| CategoryTheory.WithTerminal.of a => h_1 a
| CategoryTheory.WithTermi... | null | true |
Std.Iter.allM_eq_forIn | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {m : Type → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {p : β → m Bool},
Std.Iter.allM p it =
forIn it true fun x x_1 => do
let __do_lift ← p x
... | null | true |
PresheafOfModules.Monoidal.tensorObjMap._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
(M₁ M₂ : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))) {X Y : Cᵒᵖ} (f : X ⟶ Y)
(a : ↑((R.comp (CategoryTheory.forget₂ CommRingCat RingCat)).obj X)) (m : ↑(M₁.obj X)) (n : ↑(M₂.obj X... | null | false |
Lean.Parser.Tactic.MRefinePat.tuple.elim | Std.Tactic.Do.Syntax | {motive_1 : Lean.Parser.Tactic.MRefinePat → Sort u} →
(t : Lean.Parser.Tactic.MRefinePat) →
t.ctorIdx = 1 →
((args : List Lean.Parser.Tactic.MRefinePat) → motive_1 (Lean.Parser.Tactic.MRefinePat.tuple args)) → motive_1 t | null | false |
DifferentiableWithinAt.of_dslope | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {a b : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 (dslope f a) s b → DifferentiableWithinAt 𝕜 f s b | null | true |
Subgroup.commutator | Mathlib.GroupTheory.Commutator.Basic | {G : Type u_1} → [inst : Group G] → Bracket (Subgroup G) (Subgroup G) | The commutator of two subgroups `H₁` and `H₂`. | true |
Submodule.tensorSpanEquivSpan._proof_1 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomCompTriple (RingHom.id A) (RingHom.id A) (RingHom.id A) | null | false |
ContinuousLinearMap.opNNNorm_mul_flip_apply | Mathlib.Analysis.CStarAlgebra.Unitization | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing E]
[inst_2 : StarRing E] [NormedStarGroup E] [inst_4 : NormedSpace 𝕜 E] [inst_5 : IsScalarTower 𝕜 E E]
[inst_6 : SMulCommClass 𝕜 E E] [RegularNormedAlgebra 𝕜 E] (a : E), ‖(ContinuousLinearMap.mul 𝕜 E).flip a‖₊ = ... | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.compacts._proof_1_12 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (K : TopologicalSpace.Compacts α) (w : Set (Set α)),
(¬∀ W ∈ w, (↑K ∩ W).Nonempty) → ∀ W ∈ {W | W ∈ w ∧ (↑K ∩ W).Nonempty}, (↑K ∩ W).Nonempty | null | false |
iter_deriv_inv' | Mathlib.Analysis.Calculus.Deriv.ZPow | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (k : ℕ),
deriv^[k] Inv.inv = fun x => (-1) ^ k * ↑k.factorial * x ^ (-1 - ↑k) | null | true |
Mathlib.Tactic.Bicategory.StructuralOfExpr_bicategoricalComp | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : CategoryTheory.BicategoricalCoherence g h] (η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.bicategoricalIsoComp η' θ').hom = CategoryTheory.bicategoricalComp η θ | null | true |
Set.bijOn_empty_iff_right | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {t : Set β} {f : α → β}, Set.BijOn f ∅ t ↔ t = ∅ | null | true |
_private.Plausible.Tactic.0._aux_Plausible_Tactic___elabRules_plausibleSyntax_1.match_6 | Plausible.Tactic | (motive : Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(__discr : Array Lean.FVarId × Lean.MVarId) →
((fst : Array Lean.FVarId) → (g : Lean.MVarId) → motive (fst, g)) → motive __discr | null | false |
CategoryTheory.Mon.monMonoidalStruct_tensorObj_X | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C),
(CategoryTheory.MonoidalCategoryStruct.tensorObj M N).X = CategoryTheory.MonoidalCategoryStruct.tensorObj M.X N.X | null | true |
RootPairing.weylGroup.induction | Mathlib.LinearAlgebra.RootSystem.WeylGroup | ∀ {ι : 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)
{pred : (g : P.Aut) → g ∈ P.weylGroup → Prop},
(∀ (i : ι), pred (RootPairing.Equiv.reflection P i) ⋯) →
pr... | null | true |
CategoryTheory.ObjectProperty.tStructure._proof_8 | Mathlib.CategoryTheory.Triangulated.TStructure.Induced | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | false |
Poly.instOne | Mathlib.NumberTheory.Dioph | {α : Type u_1} → One (Poly α) | null | true |
HomogeneousLocalization.NumDenSameDeg.instCommMonoid._proof_5 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} (x : Submonoid A) [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι]
[inst_5 : GradedRing 𝒜] (x_1 : HomogeneousLocalization.NumDenSameDeg 𝒜 x), x_1 * 1 = x_1 | null | false |
Rack.toEnvelGroup.mapAux.eq_2 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G)) (x_1 : R),
Rack.toEnvelGroup.mapAux f (Rack.PreEnvelGroup.incl x_1) = f x_1 | null | true |
Std.DTreeMap.Raw.Const.mem_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF →
∀ {k k' : α} {f : Option β → Option β},
k' ∈ Std.DTreeMap.Raw.Const.alter t k f ↔
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Raw.Const.get? t k)).isSome = true else k' ∈ t | null | true |
Representation.coindV._proof_3 | Mathlib.RepresentationTheory.Coinduced | ∀ {k : Type u_4} {G : Type u_3} {H : Type u_1} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
{A : Type u_2} [inst_3 : AddCommMonoid A] [inst_4 : Module k A] (σ : Representation k G A) (x : k),
∀ x_1 ∈ {f | ∀ (g : G) (h : H), f (φ g * h) = (σ g) (f h)},
x • x_1 ∈ {f | ∀ (g : G) (h : H)... | null | false |
Quaternion.imK_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), (star a).imK = -a.imK | null | true |
Finsupp.mem_support_iff._simp_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | null | false |
ContinuousMonoidHom.mk._flat_ctor | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : TopologicalSpace A] →
[inst_3 : TopologicalSpace B] →
(toFun : A → B) →
toFun 1 = 1 →
(∀ (x y : A), toFun (x * y) = toFun x * toFun y) →
autoPar... | null | false |
CommRing.Pic.mapAlgebra_self_apply | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} [inst : CommSemiring R] {M : CommRing.Pic R}, (CommRing.Pic.mapAlgebra R R) M = M | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.getCaseGoals.showTagName | Lean.Elab.Tactic.BuiltinTactic | Lean.Name → Lean.MessageData | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.rankFinite_iff_cRank_lt_aleph0.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u_1} {M : Matroid α} (motive : M.RankFinite → Prop) (h : M.RankFinite),
(∀ (B : Set α) (hB : M.IsBase B) (fin : B.Finite), motive ⋯) → motive h | null | false |
ProbabilityTheory.covarianceBilinDual_apply | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {μ : MeasureTheory.Measure E}
[inst_1 : NormedSpace ℝ E] [inst_2 : BorelSpace E] [CompleteSpace E] [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.MemLp id 2 μ →
∀ (L₁ L₂ : StrongDual ℝ E),
((ProbabilityTheory.covarianceBilinDual μ) ... | null | true |
LieModule.Weight.coe_weight_mk | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u_2} {L : Type u_3} (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (χ : L → R) (h : LieModule.genWeightSpace M χ ≠ ⊥),
⇑{ toFun :=... | null | true |
IsIdempotentElem.one_sub_iff._simp_1 | Mathlib.Algebra.Ring.Idempotent | ∀ {R : Type u_1} [inst : NonAssocRing R] {a : R}, IsIdempotentElem (1 - a) = IsIdempotentElem a | null | false |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.evalCast._proof_7 | Mathlib.Tactic.Algebra.Basic | ∀ {v : Lean.Level} {A : Q(Type v)} (rA : Q(DivisionSemiring «$A»)) (dsA : Q(Semifield «$A»)),
«$rA» =Q «$dsA».toDivisionSemiring | null | false |
SSet.Subcomplex.Pairing.op._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Op | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing),
⇑SSet.Subcomplex.N.opEquiv ⁻¹' P.I ∩ ⇑SSet.Subcomplex.N.opEquiv ⁻¹' P.II = ∅ | null | false |
StateTransition.EvalsTo.mk | Mathlib.Computability.StateTransition | {σ : Type u_1} →
{f : σ → Option σ} →
{a : σ} → {b : Option σ} → (steps : ℕ) → (flip bind f)^[steps] (some a) = b → StateTransition.EvalsTo f a b | null | true |
Real.nonempty_algEquiv_or | Mathlib.Analysis.Complex.Polynomial.Basic | ∀ (F : Type u_1) [inst : Field F] [inst_1 : Algebra ℝ F] [Algebra.IsAlgebraic ℝ F],
Nonempty (F ≃ₐ[ℝ] ℝ) ∨ Nonempty (F ≃ₐ[ℝ] ℂ) | An algebraic extension of ℝ is isomorphic to either ℝ or ℂ as an ℝ-algebra. | true |
deriv_fun_mul | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {𝔸 : Type u_3} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {c d : 𝕜 → 𝔸},
DifferentiableAt 𝕜 c x → DifferentiableAt 𝕜 d x → deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x | null | true |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivUnitIsoApp | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasProducts C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
{ι : Type v'} →
(U : ι → TopologicalSpace.Opens ↑X) →
(c : CategoryTheory.Limits.Cone ((CategoryTheory.Pairwise.d... | Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. | true |
mul_inv_lt_iff₀' | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b c : G₀},
0 < c → (b * c⁻¹ < a ↔ b < c * a) | See `mul_inv_lt_iff₀` for a version with multiplication on the other side. | true |
Graph.IsSubgraph.isLoopAt_congr | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G H : Graph α β},
H ≤ G → e ∈ H.edgeSet → (H.IsLoopAt e x ↔ G.IsLoopAt e x) | null | true |
AddMonoidHom.coe_finsuppSum | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_7} {N : Type u_10} {P : Type u_11} [inst : Zero β] [inst_1 : AddZeroClass N]
[inst_2 : AddCommMonoid P] (f : α →₀ β) (g : α → β → N →+ P), ⇑(f.sum g) = f.sum fun i fi => ⇑(g i fi) | null | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.Const.mem_toArray_iff_get?_eq_some._simp_1_1 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
Std.DHashMap.Raw.Const.toArray ↑m = (Std.DHashMap.Raw.Const.toList ↑m).toArray | null | false |
Lean.Parser.«command_Builtin_cbv_simproc_decl_(_):=_» | Init.CbvSimproc | Lean.ParserDescr | null | true |
CategoryTheory.instMonoidalCategoryHom._proof_1 | Mathlib.CategoryTheory.Bicategory.End | ∀ {C : Type u_2} [inst : CategoryTheory.Bicategory C] (X : C) {X₁ Y₁ X₂ Y₂ : X ⟶ X} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
CategoryTheory.CategoryStruct.comp ((fun {x x_1} η h => CategoryTheory.Bicategory.whiskerRight η h) f X₂)
((fun {f x x_1} η => CategoryTheory.Bicategory.whiskerLeft f η) g) =
CategoryTheory.Categ... | null | false |
derivWithin_congr_set' | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s t : Set 𝕜} (y : 𝕜),
s =ᶠ[nhdsWithin x {y}ᶜ] t → derivWithin f s x = derivWithin f t x | null | true |
Aesop.Script.LazyStep.tacticBuilders_ne._autoParam | Aesop.Script.Step | Lean.Syntax | null | false |
UInt64.toUInt8_toUSize | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUSize.toUInt8 = n.toUInt8 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.toArray_filter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Int.natBitwise.eq_1 | Mathlib.Data.Int.Bitwise | ∀ (f : Bool → Bool → Bool) (m n : ℕ),
Int.natBitwise f m n =
bif f false false then Int.negSucc (Nat.bitwise (fun x y => !f x y) m n) else ↑(Nat.bitwise f m n) | null | true |
_private.Mathlib.RingTheory.Localization.Basic.0.IsLocalization.commutes._simp_1_1 | Mathlib.RingTheory.Localization.Basic | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
AddSubsemigroup.equivMapOfInjective.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (S : AddSubsemigroup M) (f : M →ₙ+ N)
(hf : Function.Injective ⇑f), S.equivMapOfInjective f hf = { toEquiv := Equiv.Set.image (⇑f) (↑S) hf, map_add' := ⋯ } | null | true |
CategoryTheory.NonPreadditiveAbelian.monoIsKernelOfCokernel | Mathlib.CategoryTheory.Abelian.NonPreadditive | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.NonPreadditiveAbelian C] →
{X Y : C} →
{f : X ⟶ Y} →
[CategoryTheory.Mono f] →
(s : CategoryTheory.Limits.Cofork f 0) →
CategoryTheory.Limits.IsColimit s →
Category... | In a `NonPreadditiveAbelian` category, a mono is the kernel of its cokernel. More precisely:
If `f` is a monomorphism and `s` is some colimit cokernel cocone on `f`, then `f` is a kernel
of `Cofork.π s`. | true |
Set.mul_subset_mul | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ⊆ t₁ → s₂ ⊆ t₂ → s₁ * s₂ ⊆ t₁ * t₂ | null | true |
UInt8.toUSize_shiftRight | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a >>> b).toUSize = a.toUSize >>> (b.toUSize % 8) | null | true |
ModuleCat.coprodIsoDirectSum | Mathlib.Algebra.Category.ModuleCat.Products | {R : Type u} →
[inst : Ring R] →
{ι : Type v} →
(Z : ι → ModuleCat R) →
[DecidableEq ι] →
[inst_2 : CategoryTheory.Limits.HasCoproduct Z] → ∐ Z ≅ ModuleCat.of R (DirectSum ι fun i => ↑(Z i)) | The categorical coproduct of a family of objects in `ModuleCat`
agrees with direct sum.
| true |
CategoryTheory.Functor.CoreMonoidal.toOplaxMonoidal._proof_4 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal) (x : C),
(CategoryTheory.MonoidalCategoryStr... | null | false |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.lowerHemicontinuous_iff_isOpen_compl_preimage_Iic_compl._simp_1_6 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s = ∀ x ∈ s, s ∈ nhds x | null | false |
Function.Even.eq_1 | Mathlib.Analysis.Fourier.ZMod | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] (f : α → β), Function.Even f = ∀ (a : α), f (-a) = f a | null | true |
SupHom.copy._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Max α] [inst_1 : Max β] (f : SupHom α β) (f' : α → β),
f' = ⇑f → ∀ (a b : α), f' (a ⊔ b) = f' a ⊔ f' b | null | false |
Std.HashMap.mem_insertManyIfNewUnit_list._simp_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} [EquivBEq α] [LawfulHashable α] {l : List α}
{k : α}, (k ∈ m.insertManyIfNewUnit l) = (k ∈ m ∨ l.contains k = true) | null | false |
Std.HashSet.forIn_eq_forIn_toList | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} {δ : Type v} {m' : Type v → Type w} [inst : Monad m']
[LawfulMonad m'] {f : α → δ → m' (ForInStep δ)} {init : δ}, forIn m init f = forIn m.toList init f | null | true |
SignType.LE | Mathlib.Data.Sign.Defs | SignType → SignType → Prop | The less-than-or-equal relation on signs. | true |
_private.Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.0.Mathlib.Tactic.Linarith.CertificateOracle.simplexAlgorithmDense.match_1 | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm | (hyps : List Mathlib.Tactic.Linarith.Comp) →
(maxVar : ℕ) →
(motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.DenseMatrix (maxVar + 1) hyps.length × List ℕ → Sort u_1) →
(x : Mathlib.Tactic.Linarith.SimplexAlgorithm.DenseMatrix (maxVar + 1) hyps.length × List ℕ) →
((A : Mathlib.Tactic.Linarith.Simp... | null | false |
Lean.Server.Completion.ContextualizedCompletionInfo.ctx | Lean.Server.Completion.CompletionUtils | Lean.Server.Completion.ContextualizedCompletionInfo → Lean.Elab.ContextInfo | null | true |
CategoryTheory.Monad.beckAlgebraCoequalizer._proof_3 | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
(s :
CategoryTheory.Limits.Cofork (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)),
CategoryTheory.CategoryStruct.comp (T.map X.a) s.π.f = Category... | null | false |
List.dropLastTR | Init.Data.List.Impl | {α : Type u_1} → List α → List α | Removes the last element of the list, if one exists.
This is a tail-recursive version of `List.dropLast`, used at runtime.
Examples:
* `[].dropLastTR = []`
* `["tea"].dropLastTR = []`
* `["tea", "coffee", "juice"].dropLastTR = ["tea", "coffee"]`
| true |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.bddAbove_rayleighQuotient.match_1_1 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (x : ℝ) (motive : (x ∈ Set.range fun x => |T.rayleighQuotient x|) → Prop)
(x_1 : x ∈ Set.range fun x => |T.rayleighQuotient x|),
(∀ (y : E) (h : (fun x => |T.rayleighQuotient x|) ... | null | false |
Profinite.toCompHaus.reflective._proof_2 | Mathlib.Topology.Category.Profinite.Basic | (CompHausLike.toCompHausLike Profinite.toCompHaus.reflective._proof_1).Full | null | false |
Lean.Meta.reduceNatNativeUnsafe | Lean.Meta.WHNF | Lean.Name → Lean.MetaM ℕ | null | true |
Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {p : Type u_2} {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : DecidableEq n] [inst_2 : DecidableEq p]
[inst_3 : Fintype n] [inst_4 : Fintype p] (M : Matrix p p 𝕜) (e : p ≃ n),
(∃ L L' D,
(List.map Matrix.TransvectionStruct.toMatrix L).prod * (Matrix.reindexAlgEquiv 𝕜 𝕜 e) M *
(List.... | Reduction to diagonal form by elementary operations is invariant under reindexing. | true |
Matrix.discr | Mathlib.LinearAlgebra.Matrix.Charpoly.Disc | {R : Type u_1} → {n : Type u_2} → [CommRing R] → [Fintype n] → [DecidableEq n] → Matrix n n R → R | The discriminant of a matrix is defined to be the discriminant of its characteristic
polynomial. | true |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_hom | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).hom =
CategoryTheory.CategoryStruct.comp (F.mapComp f (CategoryTheory.CategoryStruct... | null | true |
_private.Mathlib.Algebra.MonoidAlgebra.Module.0.MonoidAlgebra.mem_supported'._simp_1_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_2} {M : Type u_4} {S : Type u_5} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
{s : Set M} {x : MonoidAlgebra S M}, (x ∈ MonoidAlgebra.supported R S s) = (↑x.coeff.support ⊆ s) | null | false |
Monoid.Coprod.swap_bijective | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N],
Function.Bijective ⇑(Monoid.Coprod.swap M N) | null | true |
CategoryTheory.Functor.ranCounit_app_whiskerLeft_ranAdjunction_unit_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasRightKanExtension F] (G : CategoryTheory.... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go_get_aux._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α),
∀ curr ≤ w, ∀ idx < curr, idx < w | null | false |
IsLeftCancelMul.mk | Mathlib.Algebra.Group.Defs | ∀ {G : Type u} [inst : Mul G], (∀ (a : G), IsLeftRegular a) → IsLeftCancelMul G | null | true |
Associates.instCommMonoid._proof_4 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦1 * a⟧ = ⟦a⟧ | null | false |
Set.inv_smul_set_distrib₀ | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} [inst : GroupWithZero α] (a : α) (s : Set α), (a • s)⁻¹ = MulOpposite.op a⁻¹ • s⁻¹ | null | true |
DFA.recOn | Mathlib.Computability.DFA | {α : Type u} →
{σ : Type v} →
{motive : DFA α σ → Sort u_1} →
(t : DFA α σ) →
((step : σ → α → σ) →
(start : σ) → (accept : Set σ) → motive { step := step, start := start, accept := accept }) →
motive t | null | false |
instDecidableEqZNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬ZNum.zero = ZNum.neg a | null | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.span_range_mk_kerGen | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_4}
{P : Algebra.Generators R S ι} {σ : Type u_5} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
Submodule.span (Algebra.Generators.Presentatio... | null | true |
_private.Mathlib.MeasureTheory.Measure.SubFinite.0.MeasureTheory.Measure.withDensity_sub._simp_1_3 | Mathlib.MeasureTheory.Measure.SubFinite | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Fin.partialProd_succ' | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin (n + 1) → M) (j : Fin (n + 1)),
Fin.partialProd f j.succ = f 0 * Fin.partialProd (Fin.tail f) j | null | true |
CategoryTheory.locallyDiscreteBicategory._proof_10 | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {a b c d : CategoryTheory.LocallyDiscrete C} (f : a ⟶ b)
(g : b ⟶ c) {h h' : c ⟶ d} (η : h ⟶ h'),
CategoryTheory.eqToHom ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToIso ⋯).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | false |
Heyting.Regular.toRegular._proof_1 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (a : α), Heyting.IsRegular aᶜᶜ | null | false |
RatFunc.valuationIdeal._proof_2 | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [inst_2 : v.IsNontrivial] [inst_3 : Valuation.IsTrivialOn K v] (hle : v RatFunc.X ≤ 1),
Polynomial K ∙ RatFunc.uniformizingPolynomial hle ≠ ⊥ | null | false |
SecondCountableTopology.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{motive : SecondCountableTopology α → Sort u_1} →
(t_1 : SecondCountableTopology α) →
((is_open_generated_countable : ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b) → motive ⋯) → motive t_1 | null | false |
NormedAddGroup.ofSeparation.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] (h : ∀ (x : E), ‖x‖ = 0 → x = 0),
NormedAddGroup.ofSeparation h =
{ toNorm := inst.toNorm, toAddGroup := inst.toAddGroup, toPseudoMetricSpace := inst.toPseudoMetricSpace,
eq_of_dist_eq_zero := ⋯, dist_eq := ⋯ } | null | true |
Module.Flat.top_mul_submoduleAlgebra | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {A : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (e : TensorProduct R A M ≃ₗ[A] A) [Module.Flat R M] [FaithfulSMul R A],
⊤ * Module.Flat.submoduleAlgebra e = ⊤ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.