name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ZMod.val.match_1 | Mathlib.Data.ZMod.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Finset.mul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], Finset.mul = { mul := Finset.image₂ fun x1 x2 => x1 * x2 } | null | true |
NonemptyInterval.subtractionCommMonoid._proof_10 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α], AddRightMono α | null | false |
_private.Init.Data.Option.Lemmas.0.Option.merge.match_1.eq_4 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : Option α → Option α → Sort u_2) (x y : α) (h_1 : Unit → motive none none)
(h_2 : (x : α) → motive (some x) none) (h_3 : (y : α) → motive none (some y))
(h_4 : (x y : α) → motive (some x) (some y)),
(match some x, some y with
| none, none => h_1 ()
| some x, none => h_2 x
| n... | null | true |
CategoryTheory.Limits.isLimitConeOfCoconeUnop._proof_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ)
{c : CategoryTheory.Limits.Cocone F.unop} (hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F)
(j : Jᵒᵖ),
(CategoryTheory.Cate... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
PythagoreanTriple.mul_isClassified | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ), h.IsClassified → ⋯.IsClassified | null | true |
Std.Packages.LinearPreorderOfOrdArgs.decidableLT._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | null | false |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE.getTFAEList.match_1 | Mathlib.Tactic.TFAE | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) →
((tfae : Lean.Expr) → (l : Q(List Prop)) → motive (tfae.app l)) → ((x : Lean.Expr) → motive x) → motive __x | null | false |
ULift.leftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelSemigroup α],
ULift.leftCancelSemigroup = Function.Injective.leftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ | null | true |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.SMul.0.MeasureTheory.eLpNormEssSup_const_smul_le._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
[inst_2 : SMulZeroClass α β] [IsBoundedSMul α β] (r : α) (x : β), (‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊) = True | null | false |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.conjGL_coe._simp_1_4 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Group α] [inst_2 : MulDistribMulAction α G] {a : α}
{S : Subgroup G} {x : G}, (x ∈ a⁻¹ • S) = (a • x ∈ S) | null | false |
le_imp_le_of_le_of_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b c d : α}, c ≤ a → b ≤ d → a ≤ b → c ≤ d | monotonicity of `≤` with respect to `→` | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr → Lean.Expr → Lean.BinderInfo → Lean.MetaM Bool | Determine whether the argument should be ignored. | true |
CategoryTheory.Limits.HasPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y Z : C} → (X ⟶ Y) → (X ⟶ Z) → Prop | Two morphisms `f : X ⟶ Y` and `g : X ⟶ Z` have a pushout if the diagram `span f g` has a
colimit. | true |
_private.Std.Data.String.ToInt.0.String.Slice.isInt_congr._simp_1_1 | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.isInt = s.toInt?.isSome | null | false |
AddCommGrpCat.addCommGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddCommGrpCat) → (j : J) → Zero ((F.comp (CategoryTheory.forget AddCommGrpCat)).obj j) | null | false |
Algebra.TensorProduct.algebraMap_def | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : CommSemiring S] [inst_6 : Algebra S A]
[inst_7 : SMulCommClass R S A],
algebraMap S (TensorProduct R A B) = Algebra.TensorProduct.in... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayerTarget.w | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} → {outWidth : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayerTarget aig outWidth → ℕ | null | true |
Std.Http.Protocol.H1.Reader.messageCount | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → ℕ | Count of messages that this connection has already parsed.
| true |
CategoryTheory.Pretopology.gi | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
GaloisInsertion CategoryTheory.Pretopology.toGrothendieck CategoryTheory.GrothendieckTopology.toPretopology | We have a Galois insertion from pretopologies to Grothendieck topologies. | true |
CategoryTheory.Limits.instHasCokernelFromSubtype | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {K : Type}
[inst_2 : Finite K] [inst_3 : CategoryTheory.Limits.HasFiniteBiproducts C] (f : K → C) (p : K → Prop),
CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.biproduct.fromSubtype f p) | null | true |
logDeriv_congr_nhds | Mathlib.Analysis.Calculus.LogDeriv | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {f g : 𝕜 → 𝕜'} {x : 𝕜}, f =ᶠ[nhds x] g → logDeriv f =ᶠ[nhds x] logDeriv g | If two functions agree in a neighborhood of `x`, then so do their logarithmic derivatives. | true |
JoinedIn.pi | Mathlib.Topology.Connected.PathConnected | ∀ {ι : Type u_3} {Z : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (Z i)] {s : (i : ι) → Set (Z i)}
{x y : (i : ι) → Z i}, (∀ (i : ι), JoinedIn (s i) (x i) (y i)) → JoinedIn (Set.univ.pi s) x y | If for each `i`, `x i` is joined to `y i` within `s i`, then `x` is joined to `y` within the
product set `Set.univ.pi s`. | true |
Equiv.ofRightInverseOfCardLE_apply | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (hαβ : Fintype.card α ≤ Fintype.card β)
(f : α → β) (g : β → α) (h : Function.RightInverse g f) (a : α), (Equiv.ofRightInverseOfCardLE hαβ f g h) a = f a | null | true |
NonUnitalSubalgebra.instModule._proof_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A],
IsScalarTower R R A | null | false |
List.countP_cons_of_neg | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, ¬p a = true → List.countP p (a :: l) = List.countP p l | null | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isComplete_iff_ultrafilter'._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
Std.TreeMap.maxKey_le_maxKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α} {v : β}
{he : t.isEmpty = false}, (cmp (t.maxKey he) ((t.insert k v).maxKey ⋯)).isLE = true | null | true |
Aesop.RuleBuilderOptions.mk | Aesop.Builder.Basic | Option (Array Lean.Name) →
Option Aesop.IndexingMode →
Option (Array Aesop.CasesPattern) →
Option Lean.Term →
Option Lean.Meta.TransparencyMode → Option Lean.Meta.TransparencyMode → Aesop.RuleBuilderOptions | null | true |
MeasureTheory.setLIntegral_congr_fun | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal} {s : Set α},
MeasurableSet s → Set.EqOn f g s → ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ | null | true |
_private.Mathlib.Combinatorics.Quiver.Schreier.0.Quiver.SchreierGraph.reachable_iff.match_1_1 | Mathlib.Combinatorics.Quiver.Schreier | ∀ {V : Type u_1} {M : Type u_3} [inst : Group M] [inst_1 : MulAction M V] {S : Type u_2} (ι : S → M)
(x y : Quiver.SchreierGraph V ι)
(motive : Quiver.Reachable (Quiver.Symmetrify.of.obj x) (Quiver.Symmetrify.of.obj y) → Prop)
(x_1 : Quiver.Reachable (Quiver.Symmetrify.of.obj x) (Quiver.Symmetrify.of.obj y)),
(... | null | false |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.preprocess | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Expr → Lean.Expr → Bool → Bool → Lean.MetaM (List (Lean.Expr × Lean.Expr)) | null | true |
OrderedFinpartition.compAlongOrderedFinpartitionL_apply | 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 | true |
isLocalMax_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b {b}ᶜ, DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) → IsLocalMax f b | The First Derivative test, maximum version. | true |
BoundedContinuousFunction.instAddZeroClass | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddZeroClass R] → [BoundedAdd R] → [ContinuousAdd R] → AddZeroClass (BoundedContinuousFunction α R) | null | true |
instPartialOrderEReal._proof_8 | Mathlib.Data.EReal.Basic | ∀ (a b : EReal), a ≤ b → b ≤ a → a = b | null | false |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.erase.eq_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} [inst : BEq α] (c : Std.Sat.CNF.Clause α) (lit : Std.Sat.Literal α),
c.erase lit = Std.Sat.CNF.Clause.erase.go✝ c lit 0 Std.Sat.CNF.Clause.empty | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.ωConj._simp_4 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
LinearEquiv.finTwoArrow_apply | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⇑(LinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1) | null | true |
NNRat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_2} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ≥0} {n : ℕ},
(↑m < ↑n) = (m < ↑n) | null | false |
MulChar.ofUnitHom.eq_1 | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ),
MulChar.ofUnitHom f =
{ toFun := fun x => if hx : IsUnit x then ↑(f hx.unit) else 0, map_one' := ⋯, map_mul' := ⋯, map_nonunit' := ⋯ } | null | true |
CStarMatrix.map_map | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {C : Type u_7} {M : Matrix m n A} {f : A → B} {g : B → C},
(M.map f).map g = M.map (g ∘ f) | null | true |
AddLocalization.le._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] {s : AddSubmonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(AddLocalization.r s) (a₁, a₂) (b₁, b₂) →
(AddLocalization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ + a₁ ≤ ↑a₂ + c₁) = (↑d₂ + b₁ ≤ ↑b₂ + d₁) | null | false |
_private.Mathlib.Tactic.Simproc.Factors.0.Nat.primeFactorsList_ofNat.match_3 | Mathlib.Tactic.Simproc.Factors | (motive :
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Sort u_1) →
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e))... | null | false |
Std.ExtTreeMap.contains_eq_isSome_getElem? | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α},
t.contains a = t[a]?.isSome | null | true |
OrderAddMonoidHom.comp | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Preorder γ] →
[inst_3 : AddZeroClass α] →
[inst_4 : AddZeroClass β] → [inst_5 : AddZeroClass γ] → (β →+o γ) → (α →+o β) → α →+o γ | Composition of `OrderAddMonoidHom`s as an `OrderAddMonoidHom` | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.mkRewrite.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x | null | false |
Int8.toInt_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int8.ofNat n).toInt = (↑n).bmod Int8.size | null | true |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_functor_map_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
{X Y : CategoryTheory.Functor (CategoryTheory.WithInitial SimplexCategory) C} (η : X ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.functor.map η).left = η.app CategoryTheory.WithInitial.star | null | true |
OrderHom.coe_antisymmetrization | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β),
⇑f.antisymmetrization = Quotient.map' ⇑f ⋯ | null | true |
Lean.ModuleSetup.mk.sizeOf_spec | Lean.Setup | ∀ (name : Lean.Name) (package? : Option Lean.PkgId) (isModule : Bool) (imports? : Option (Array Lean.Import))
(importArts : Lean.NameMap Lean.ImportArtifacts) (dynlibs : Array System.FilePath) (plugins : Array Lean.Plugin)
(options : Lean.LeanOptions),
sizeOf
{ name := name, package? := package?, isModule :... | null | true |
isCancelMul_iff | Mathlib.Algebra.Group.Semigroup | ∀ (G : Type u_2) [inst : Mul G], IsCancelMul G ↔ IsLeftCancelMul G ∧ IsRightCancelMul G | null | true |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.kerTotal_mkQ_single_mul._simp_1_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_4} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(fun₀ | a => c • b) = c • fun₀ | a => b | null | false |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.mem_rcons_iff._proof_1_13 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈
(if h : p.head = 1 then p.tail
else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
⟨j, m⟩ ∈ ... | null | false |
CategoryTheory.ShortComplex.SnakeInput.functorP_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorP.obj S = S.P | null | true |
HNNExtension.NormalWord.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{d : HNNExtension.NormalWord.TransversalPair G A B} →
{t : HNNExtension.NormalWord d} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{d' : H... | null | false |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiSnd | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q), CategoryTheory.IsSplitEpi c.snd | null | true |
CategoryTheory.Functor.CorepresentableBy.isoCoreprX | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type v)} →
[hF : F.IsCorepresentable] → {Y : C} → F.CorepresentableBy Y → (Y ≅ F.coreprX) | Any corepresenting object for a corepresentable functor `F` is isomorphic to `coreprX F`. | true |
Matrix.toLinOfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_3} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{M₁ : Type u_1} {M₂ : Type u_2} [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R M₁]
[inst_6 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis m R M₂) [inst_7 : F... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Cartan.Basic.0.CartanMatrix.C_off_diag_nonpos._proof_1_2 | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ (n : ℕ) (i j : Fin n), i ≠ j → i = j → 2 ≤ 0 | null | false |
Lean.Expr.ReplaceLevelImpl.State._sizeOf_inst | Lean.Util.ReplaceLevel | SizeOf Lean.Expr.ReplaceLevelImpl.State | null | false |
List.Sublist.findIdx?_isSome | Init.Data.List.Find | ∀ {α : Type u_1} {p : α → Bool} {l₁ l₂ : List α},
l₁.Sublist l₂ → (List.findIdx? p l₁).isSome = true → (List.findIdx? p l₂).isSome = true | null | true |
_private.Mathlib.Data.Finset.Dedup.0.Multiset.toFinset_subset._simp_1_1 | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
OpenPartialHomeomorph.mapsTo_symm | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y), Set.MapsTo (↑e.symm) e.target e.source | null | true |
Matrix.uniqueAlgEquiv | Mathlib.LinearAlgebra.Matrix.Unique | {m : Type u_1} →
{A : Type u_3} →
{R : Type u_4} →
[inst : Unique m] →
[inst_1 : Semiring A] → [inst_2 : CommSemiring R] → [inst_3 : Algebra R A] → Matrix m m A ≃ₐ[R] A | `M₁(A)` is equivalent to `A` as an `R`-algebra. | true |
Lean.Parser.Tactic.revert | Init.Tactics | Lean.ParserDescr | `revert x...` is the inverse of `intro x...`: it moves the given hypotheses
into the main goal's target type.
| true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.strictConcaveOn_qaryEntropy._simp_1_1 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | null | false |
SetLike.GradeZero.coe_intCast | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {σ : Type u_2} {R : Type u_4} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A] (z : ℤ), ↑↑z = ↑z | null | true |
CategoryTheory.Adjunction.homEquiv | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D C} → (F ⊣ G) → (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y) | The hom set equivalence associated to an adjunction. | true |
Filter.Realizer.ctorIdx | Mathlib.Data.Analysis.Filter | {α : Type u_1} → {f : Filter α} → f.Realizer → ℕ | null | false |
IsEllipticNet.atom | Mathlib.NumberTheory.EllipticDivisibilitySequence | {R : Type u_1} → [CommRing R] → (ℤ → R) → ℤ → ℤ → R | The elliptic atom `Wₐ(a, b)` that defines an elliptic net. Note that this is defined in terms of
truncated integer division, and hence should only be used when `a` and `b` have the same parity. | true |
Lean.Doc.Part.brecOn_1 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
(t : Array (Lean.Doc.Part i b p)) →
((t : Lean.Doc.Part i b p) → t... | null | false |
CategoryTheory.IsAddMonHom.addMonoidHom | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{M N : C} →
[inst_2 : CategoryTheory.AddMonObj M] →
[inst_3 : CategoryTheory.AddMonObj N] →
(f : M ⟶ N) → [CategoryTheory.IsAddMonHom f] → (X : C) → (X ⟶ M) →+... | An additive monoid morphism `f : M ⟶ N` induces an additive monoid homomorphism
`M(X) →+ N(X)` for every `X`. | true |
Representation.FiniteCyclicGroup.coinvariantsEquiv | Mathlib.RepresentationTheory.Homological.FiniteCyclic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommRing k] →
[inst_1 : Group G] →
{V : Type u_4} →
[inst_2 : AddCommGroup V] →
[inst_3 : Module k V] →
(ρ : Representation k G V) →
(g : G) →
[Fintype G] →
(∀ (x : G),... | Given a finite cyclic group `G` generated by `g` and a `G` representation `(V, ρ)`, `V_G` is
isomorphic to `V ⧸ Im(ρ(g - 1))`. | true |
String.validFor_mkIterator | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.Iterator.ValidFor [] s.toList (String.Legacy.mkIterator s) | null | true |
AlgebraicGeometry.Scheme.instOverSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | {X : AlgebraicGeometry.Scheme} → (x : ↥X) → (AlgebraicGeometry.Spec (X.residueField x)).Over X | null | true |
HomologicalComplex.restriction.sc'Iso_hom_τ₃ | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) {i' j' k' : ι'}
(hi' : e.f i = i') (hj'... | null | true |
List.set_eq_modify | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (a : α) (n : ℕ) (l : List α), l.set n a = l.modify n fun x => a | null | true |
CongruenceSubgroup.Gamma1_mem._simp_1 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (N : ℕ) (A : Matrix.SpecialLinearGroup (Fin 2) ℤ),
(A ∈ CongruenceSubgroup.Gamma1 N) = (↑(↑A 0 0) = 1 ∧ ↑(↑A 1 1) = 1 ∧ ↑(↑A 1 0) = 0) | null | false |
isAddRegular_toColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : α}, IsAddRegular (toColex a) ↔ IsAddRegular a | null | true |
_private.Mathlib.CategoryTheory.Comma.Over.Basic.0.CategoryTheory.Over.isRightAdjoint_post.match_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {G : CategoryTheory.Functor D T} (motive : G.IsRightAdjoint → Prop)
(x : G.IsRightAdjoint), (∀ (F : CategoryTheory.Functor T D) (a : F ⊣ G), motive ⋯) → motive x | null | false |
MeasureTheory.JordanDecomposition.casesOn | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_2} →
[inst : MeasurableSpace α] →
{motive : MeasureTheory.JordanDecomposition α → Sort u} →
(t : MeasureTheory.JordanDecomposition α) →
((posPart negPart : MeasureTheory.Measure α) →
[posPart_finite : MeasureTheory.IsFiniteMeasure posPart] →
[negPart_finite : Me... | null | false |
RingEquiv.nonUnitalSubsemiringCongr._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {s t : NonUnitalSubsemiring R}, s = t → ↑s = ↑t | null | false |
AffineMap.finrank_eq | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ {R : Type u_1} {S : Type u_2} {V : Type u_3} {W : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Ring S]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [Module.Finite R V] [Module.Free R V] [inst_6 : AddTorsor V P]
[inst_7 : AddCommGroup W] [inst_8 : Module R W] [inst_9 : Module S W] [Module.Finite S W]
[i... | null | true |
PerfectionMap.lift._proof_4 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u_1) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p] (S : Type u_2) [inst_4 : CommSemiring S] [inst_5 : CharP S p] (P : Type u_3)
[inst_6 : CommSemiring P] [inst_7 : CharP P p] [inst_8 : PerfectRing P p] (π : P →+* S) (m : PerfectionMap p π)
... | null | false |
CategoryTheory.ComposableArrows.homMk₅_app_three' | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_453✝ ⟶ g.obj' 0 _proof_453✝) (app₁ : f.obj' 1 _proof_454✝ ⟶ g.obj' 1 _proof_454✝)
(app₂ : f.obj' 2 _proof_455✝ ⟶ g.obj' 2 _proof_455✝) (app₃ : f.obj' 3 _proof_456✝ ⟶ g.obj' 3 _proof_456... | null | true |
AlgebraicGeometry.LocallyRingedSpace.restrict_presheaf_map | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {U : TopCat} (X : AlgebraicGeometry.LocallyRingedSpace) {f : U ⟶ X.toTopCat}
(h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)) {X_1 Y : (TopologicalSpace.Opens ↑U)ᵒᵖ}
(f_1 : X_1 ⟶ Y), (X.restrict h).presheaf.map f_1 = X.presheaf.map (h.functor.map f_1.unop).op | null | true |
FiberBundleCore.Index | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → Type u_1 | The index set of a fiber bundle core, as a convenience function for dot notation | true |
Lean.Meta.Grind.instInhabitedTheorems.default | Lean.Meta.Tactic.Grind.Theorems | {α : Type} → Lean.Meta.Grind.Theorems α | null | true |
CategoryTheory.ShortComplex.ShortExact.singleδ.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S : CategoryTheory.ShortComplex C} (hS : S.ShortExact),
hS.singleδ = DerivedCategory.triangleOfSESδ ⋯ | null | true |
BooleanSubalgebra.instCompleteLattice._proof_4 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (_L _M : BooleanSubalgebra α) (_a : α), _a ∈ ↑_L ∧ _a ∈ ↑_M → _a ∈ ↑_M | null | false |
_private.Mathlib.Topology.ShrinkingLemma.0.ShrinkingLemma.PartialRefinement.chainSup._simp_8 | Mathlib.Topology.ShrinkingLemma | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Quiver.symmetrifyStar | Mathlib.Combinatorics.Quiver.Covering | {U : Type u_1} →
[inst : Quiver U] → (u : U) → Quiver.Star (Quiver.Symmetrify.of.obj u) ≃ Quiver.Star u ⊕ Quiver.Costar u | The star of the symmetrification of a quiver at a vertex `u` is equivalent to the sum of the
star and the costar at `u` in the original quiver. | true |
Lean.Compiler.LCNF.eqvTypes | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Expr → Bool | Return `true` if the given LCNF are equivalent.
`List Nat` and `(fun x => List x) Nat` are both equivalent.
| true |
CategoryTheory.Functor.CommShift.isoAdd_hom_app_assoc | Mathlib.CategoryTheory.Shift.CommShift | ∀ {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] {F : CategoryTheory.Functor C D} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] {a b : A}
(e₁ : (CategoryTheory.shiftFu... | null | true |
eventuallyMeasurableSpace._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.EventuallyMeasurable | ∀ {α : Type u_1} (m : MeasurableSpace α) (l : Filter α), ∃ t, MeasurableSet t ∧ ∅ =ᶠ[l] t | null | false |
Lean.Elab.Tactic.RCases.RCasesPatt.one | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.Name → Lean.Elab.Tactic.RCases.RCasesPatt | A named pattern like `foo` | true |
AlgebraicGeometry.Scheme.mem_zeroLocus_iff._simp_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (s : Set ↑(X.presheaf.obj (Opposite.op U))) (x : ↥X),
(x ∈ X.zeroLocus s) = ∀ f ∈ s, x ∉ X.basicOpen f | null | false |
Mathlib.Tactic.Coherence.LiftHom.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X Y : C} →
{inst_1 : Mathlib.Tactic.Coherence.LiftObj X} →
{inst_2 : Mathlib.Tactic.Coherence.LiftObj Y} →
{f : X ⟶ Y} →
{t : Mathlib.Tactic.Coherence.LiftHom f} →
{C' : T... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.