name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
GrpWithZero.groupWithZeroConcreteCategory._proof_3 | Mathlib.Algebra.Category.GrpWithZero | ∀ {X : GrpWithZero} (x : X.carrier), (CategoryTheory.CategoryStruct.id X) x = x | null | false |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_hom | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α β : X ⟶ Y) (h : α = β) (x : ↑↑X),
AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (AlgebraicGe... | null | true |
MulAlgebraNorm.noConfusionType | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | Sort u →
{R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
MulAlgebraNorm R S →
{R' : Type u_1} →
[inst' : SeminormedCommRing R'] →
{S' : Type u_2} → [inst'_1 : Ring S']... | null | false |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_1 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (h : α × β), (∀ (a : α) (b : β), motive (a, b)) → motive h | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap.0.WeierstrassCurve.termS | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | Lean.ParserDescr | null | true |
Nat.instTransLe | Init.Data.Nat.Basic | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | null | true |
SchwartzMap.fderivCLM._proof_7 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (F : Type u_1) [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
_private.Lean.Meta.Tactic.Grind.Parser.0.Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.grindPattern.parenthesizer_127 | Lean.Meta.Tactic.Grind.Parser | IO Unit | null | false |
Topology.ContinuousMapGeneratedBy.curryEquiv._proof_6 | Mathlib.Topology.Convenient.HomSpace | ∀ {ι : Type u_4} {X : ι → Type u_5} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type u_1}
[inst_1 : TopologicalSpace Y] {Z : Type u_2} [inst_2 : TopologicalSpace Z] {T : Type u_3}
[inst_3 : TopologicalSpace T] [inst_4 : ∀ (i : ι), LocallyCompactSpace (X i)]
[inst_5 : ∀ (i j : ι), Topology.IsGeneratedBy X (X i ... | null | false |
CategoryTheory.Limits.isBilimitOfIsLimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_3}
[inst_2 : Fintype J] {f : J → C} (t : CategoryTheory.Limits.Bicone f) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (∑ j, CategoryTheory.CategoryStruct.comp (t.π j) (t.ι j)) (t... | null | false |
Nat.Prime.mem_primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {n p : ℕ}, Nat.Prime p → p ∣ n → n ≠ 0 → p ∈ n.primeFactors | null | true |
trapezoidal_integral | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ | Integration of `f` from `a` to `b` using the trapezoidal rule with `N+1` total evaluations of
`f`. (Note the off-by-one problem here: `N` counts the number of trapezoids, not the number of
evaluations.) | true |
Orientation.kahler_rotation_left' | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (θ : Real.Angle),
(o.kahler ((o.rotation θ) x)) y = ↑(-θ).toCircle * (o.kahler x) y | Rotating the first of two vectors by `θ` scales their Kähler form by `cos (-θ) + sin (-θ) * I`.
| true |
commutatorElement_def | Mathlib.Algebra.Group.Commutator | ∀ {G : Type u_1} [inst : Group G] (g₁ g₂ : G), ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹ | null | true |
Polynomial.leadingCoeff_X_pow_sub_one | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Ring R] {n : ℕ}, 0 < n → (Polynomial.X ^ n - 1).leadingCoeff = 1 | null | true |
IsGreatest.nnnorm_cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Monotone.of_left_le_map_sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup α] [inst_1 : Preorder β] {f : α → β},
(∀ (x y : α), f x ≤ f (x ⊔ y)) → Monotone f | null | true |
Aesop.NormRuleResult.proved.injEq | Aesop.Search.Expansion.Norm | ∀ (steps? steps?_1 : Option (Array Aesop.Script.LazyStep)),
(Aesop.NormRuleResult.proved steps? = Aesop.NormRuleResult.proved steps?_1) = (steps? = steps?_1) | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.commandExpandersForUnsafe | Lean.Elab.DocString | Lean.Ident →
Lean.Elab.TermElabM
(Array
(Lean.Name ×
StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))) | null | true |
Matroid.IsBasis.isBasis_isRestriction | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α} {N : Matroid α},
M.IsBasis I X → N.IsRestriction M → X ⊆ N.E → N.IsBasis I X | null | true |
Lean.Meta.SolveByElim.SolveByElimConfig.testPartialSolutions | Lean.Meta.Tactic.SolveByElim | optParam Lean.Meta.SolveByElim.SolveByElimConfig { } →
(List Lean.Expr → Lean.MetaM Bool) → Lean.Meta.SolveByElim.SolveByElimConfig | Create or modify a `Config` which rejects branches for which `test`,
applied to the instantiations of the original goals, fails or returns `false`.
| true |
CategoryTheory.Functor.sheafPushforwardContinuousComp' | Mathlib.CategoryTheory.Sites.Continuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D E} →
... | When we have an isomorphism `F ⋙ G ≅ FG` between continuous functors
between sites, the composition of the pushforward functors for
`G` and `F` identifies to the pushforward functor for `FG`. | true |
CategoryTheory.LaxMonoidalFunctor.laxMonoidal._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
Con.ker_rel._simp_2 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[inst_3 : MulHomClass F M N] (f : F) {x y : M}, (Con.ker f) x y = (f x = f y) | null | false |
_private.Lean.Elab.ConfigEval.Instances.0.Lean.Elab.ConfigEval.EvalTerm.evalOptionStx.match_1 | Lean.Elab.ConfigEval.Instances | {α : Type} →
(motive : α × Lean.Expr → Sort u_1) → (x : α × Lean.Expr) → ((v : α) → (e : Lean.Expr) → motive (v, e)) → motive x | null | false |
BitVec.toInt_sub_of_not_ssubOverflow | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, ¬x.ssubOverflow y = true → (x - y).toInt = x.toInt - y.toInt | null | true |
_private.Mathlib.Analysis.Analytic.Inverse.0.FormalMultilinearSeries.rightInv_removeZero.match_1_1 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E)
(motive : (n : ℕ) → (∀ m < n, p.removeZero.right... | null | false |
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s t : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit t → (s.pt ≅ t.... | Limits of `F` are unique up to isomorphism. | true |
CategoryTheory.Limits.evaluation_preservesColimit_of_hasCokernel_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Kernels | ∀ {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₁ F₂ : CategoryTheory.Functor J C} (f : F₁ ⟶ F₂) [∀ (j : J), CategoryTheory.Limits.HasCokernel (f.app j)] (j : J),
CategoryTheory.Limi... | null | true |
Cardinal.ofENat_le_lift._simp_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {x : Cardinal.{v}} {m : ℕ∞}, (↑m ≤ Cardinal.lift.{u, v} x) = (↑m ≤ x) | null | false |
List.minOn_eq_min | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : LE α] [DecidableLE α] [Std.LawfulOrderLeftLeaningMin α]
[inst_4 : LE β] [inst_5 : DecidableLE β] {f : α → β} {l : List α} {h : l ≠ []},
(∀ (a b : α), f a ≤ f b ↔ a ≤ b) → List.minOn f l h = l.min h | null | true |
CategoryTheory.EffectiveEquivalenceRelation.noConfusion | Mathlib.CategoryTheory.EquivalenceRelation | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{R A : C} →
{p₁ p₂ : R ⟶ A} →
{t : CategoryTheory.EffectiveEquivalenceRelation p₁ p₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} C'} →
{R' A' : C'}... | null | false |
nhds_subtype_eq_comap | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop} {x : X} {h : p x},
nhds ⟨x, h⟩ = Filter.comap Subtype.val (nhds x) | null | true |
lt_of_lt_add_of_nonpos_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightMono α], a < b + c → b ≤ 0 → a < c | null | true |
_private.Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup.0.Algebra.GrothendieckGroup.of_injective._simp_1_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} (x : M), (Localization.monoidOf S) x = Localization.mk x 1 | null | false |
HomologicalComplex.restrictionMap_id | Mathlib.Algebra.Homology.Embedding.Restriction | ∀ {ι : 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],
HomologicalComplex.restrictionMap (CategoryTheory.... | null | true |
Lean.Meta.AbstractNestedProofs.isNonTrivialProof | Lean.Meta.AbstractNestedProofs | Lean.Expr → Lean.MetaM Bool | null | true |
strictConcaveOn_of_slope_strict_anti_adjacent | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
Convex 𝕜 s →
(∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (f z - f y) / (z - y) < (f y - f x) / (y - x)) →
StrictConcaveOn 𝕜 s f | If for any three points `x < y < z`, the slope of the secant line of `f : 𝕜 → 𝕜` on `[x, y]` is
strictly greater than the slope of the secant line of `f` on `[y, z]`, then `f` is strictly concave.
| true |
CategoryTheory.Pseudofunctor.DescentData.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
(obj : (i : ι) → ↑(F.obj { as := Opposite.op (X... | null | false |
ModularForm.sub_apply | Mathlib.NumberTheory.ModularForms.Basic | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Sub β}
{inst_2 : Sub F} [self : IsSubApply F α β] (f g : F) (x : α), (f - g) x = f x - g x | **Alias** of `sub_apply`. | true |
_private.Lean.Meta.Offset.0.Lean.Meta.evalNat._sparseCasesOn_2 | Lean.Meta.Offset | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.Meta.DiscrTree.Trie.ctorIdx | Lean.Meta.DiscrTree.Types | {α : Type} → Lean.Meta.DiscrTree.Trie α → ℕ | null | false |
_private.Mathlib.LinearAlgebra.QuadraticForm.Signature.0.QuadraticForm.posDef_spanSubset._simp_1_5 | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
UniformSpace.Completion.instAddMonoid._proof_12 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (n : ℕ)
(a : UniformSpace.Completion α), (n + 1) • a = n • a + a | null | false |
_private.Mathlib.Topology.Compactness.Lindelof.0.Tendsto.isLindelof_insert_range_of_coLindelof._simp_1_3 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty = ¬Disjoint s t | null | false |
IsLocalRing.ResidueField.map_id_apply | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] (x : IsLocalRing.ResidueField R),
(IsLocalRing.ResidueField.map (RingHom.id R)) x = x | null | true |
DomMulAct.instLeftCancelMonoidOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [LeftCancelMonoid Mᵐᵒᵖ] → LeftCancelMonoid Mᵈᵐᵃ | null | true |
Equiv.Perm.subtypeEquivSubtypePerm_apply_of_not_mem | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {p : α → Prop} [inst : DecidablePred p] {a : α} (f : Equiv.Perm (Subtype p)),
¬p a → ↑((Equiv.Perm.subtypeEquivSubtypePerm p) f) a = a | null | true |
String.Slice.Pattern.Model.CharPred.instPatternModelForallCharBool | Init.Data.String.Lemmas.Pattern.Pred | {p : Char → Bool} → String.Slice.Pattern.Model.PatternModel p | null | true |
Finsupp.sumFinsuppLEquivProdFinsupp_symm_inr | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_4}
{β : Type u_5} (fg : (α →₀ M) × (β →₀ M)) (y : β),
((Finsupp.sumFinsuppLEquivProdFinsupp R).symm fg) (Sum.inr y) = fg.2 y | null | true |
CategoryTheory.Equivalence.toAdjunction_unit | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D), e.toAdjunction.unit = e.unit | null | true |
HomologicalComplex.xNextIso.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xNextIso r = CategoryTheory.eqToIso ⋯ | null | true |
NonUnitalSeminormedRing.noConfusion | Mathlib.Analysis.Normed.Ring.Basic | {P : Sort u} →
{α : Type u_5} →
{t : NonUnitalSeminormedRing α} →
{α' : Type u_5} →
{t' : NonUnitalSeminormedRing α'} → α = α' → t ≍ t' → NonUnitalSeminormedRing.noConfusionType P t t' | null | false |
Finset.sdiff_union_erase_cancel | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, t ⊆ s → a ∈ t → s \ t ∪ t.erase a = s.erase a | null | true |
GrpCat.SurjectiveOfEpiAuxs.h_apply_fromCoset_nin_range | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
∀ x ∈ (GrpCat.Hom.hom f).range,
∀ b ∉ (GrpCat.Hom.hom f).range,
((GrpCat.SurjectiveOfEpiAuxs.h f) x)
(GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨b • ↑(GrpCat.Hom.hom f).range, ⋯⟩) =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨(x * b) • ↑(GrpCa... | null | true |
WittVector.toZModPow_compat | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (m n : ℕ) (h : m ≤ n),
(ZMod.castHom ⋯ (ZMod (p ^ m))).comp (WittVector.toZModPow p n) = WittVector.toZModPow p m | null | true |
Set.Intersecting.exists_mem_set | Mathlib.Combinatorics.SetFamily.Intersecting | ∀ {α : Type u_1} {𝒜 : Set (Set α)}, 𝒜.Intersecting → ∀ {s t : Set α}, s ∈ 𝒜 → t ∈ 𝒜 → ∃ a ∈ s, a ∈ t | null | true |
_private.Mathlib.CategoryTheory.EssentiallySmall.0.CategoryTheory.essentiallySmall_iff_of_thin._simp_1_2 | Mathlib.CategoryTheory.EssentiallySmall | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [Quiver.IsThin C],
CategoryTheory.LocallySmall.{w, v, u} C = True | null | false |
CategoryTheory.HasLiftingProperty.transfiniteComposition.sqFunctor._proof_4 | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X Y : C} (p : X ⟶ Y)
(f : F.obj ⊥ ⟶ X) (g : c.pt ⟶ Y) {X_1 Y_1 Z : Jᵒᵖ} (f_1 : X_1 ⟶ Y_1) (g_1 : Y_1 ⟶ Z),
(TypeCat.of... | null | false |
Setoid.mk_eq_bot | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {r : α → α → Prop} (iseqv : Equivalence r), { r := r, iseqv := iseqv } = ⊥ ↔ r = fun x1 x2 => x1 = x2 | null | true |
Real.sinhOrderIso_symm_apply | Mathlib.Analysis.SpecialFunctions.Arsinh | ⇑(RelIso.symm Real.sinhOrderIso) = Real.arsinh | null | true |
_private.Mathlib.Algebra.Homology.Monoidal.0.HomologicalComplex.instHasTensorTensorUnit_1._proof_1 | Mathlib.Algebra.Homology.Monoidal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Limits.HasZeroObject C]
[inst_4 : (CategoryTheory.MonoidalCategory.curriedTensor C).Additive]
[inst_5 : ∀ (X₁ : C), ((CategoryTheory.Monoidal... | null | false |
CategoryTheory.PreOneHypercover.Hom.mk | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
(toHom : E.Hom F.toPreZeroHypercover) →
(s₁ : {i j : E.I₀} → E.I₁ i j → F.I₁ (toHom.s₀ i) (toHom.s₀ j)) →
(h₁ :... | null | true |
_private.Init.Data.List.Sublist.0.List.infix_filterMap_iff._simp_1_3 | Init.Data.List.Sublist | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {L₁ L₂ : List β} {f : α → Option β},
(List.filterMap f l = L₁ ++ L₂) = ∃ l₁ l₂, l = l₁ ++ l₂ ∧ List.filterMap f l₁ = L₁ ∧ List.filterMap f l₂ = L₂ | null | false |
CategoryTheory.Limits.Multicoequalizer.instHasCoequalizerFstSigmaMapSndSigmaMap | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.left] [inst_3 : CategoryTheory.Limits.HasCoproduct I.right],
CategoryTheor... | null | true |
_private.Mathlib.Algebra.Ring.Idempotent.0.IsIdempotentElem.sub_iff._simp_1_5 | Mathlib.Algebra.Ring.Idempotent | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
FreeMonoid.prodAux.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {M : Type u_6} [inst : Monoid M], FreeMonoid.prodAux [] = 1 | null | true |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Simp.Types | ∀ (config : Lean.Meta.Simp.Config) (userConfig : Lean.Options) (zetaDeltaSet initUsedZetaDelta : Lean.FVarIdSet)
(metaConfig indexConfig : Lean.Meta.ConfigWithKey) (maxDischargeDepth : UInt32)
(simpTheorems : Lean.Meta.SimpTheoremsArray) (congrTheorems : Lean.Meta.SimpCongrTheorems)
(parent? : Option Lean.Expr) (... | null | true |
borel_eq_generateFrom_Ioi | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ (α : Type u_1) [inst : TopologicalSpace α] [SecondCountableTopology α] [inst_2 : LinearOrder α] [OrderTopology α],
borel α = MeasurableSpace.generateFrom (Set.range Set.Ioi) | null | true |
CommAlgCat.binaryCofanIsColimit._proof_1 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (A B : CommAlgCat R) {T : CommAlgCat R} (f : A ⟶ T) (g : B ⟶ T),
CategoryTheory.CategoryStruct.comp (A.binaryCofan B).inl
(CommAlgCat.ofHom (Algebra.TensorProduct.lift (CommAlgCat.Hom.hom f) (CommAlgCat.Hom.hom g) ⋯)) =
f | null | false |
iteratedFDeriv_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ},
iteratedFDeriv 𝕜 n 0 = 0 | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode | Lean.Compiler.LCNF.ToLCNF | Array Lean.Compiler.LCNF.ToLCNF.Element✝ →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | null | true |
Matrix.cramer | Mathlib.LinearAlgebra.Matrix.Adjugate | {n : Type v} → {α : Type w} → [DecidableEq n] → [Fintype n] → [inst : CommRing α] → Matrix n n α → (n → α) →ₗ[α] n → α | `cramer A b i` is the determinant of the matrix `A` with column `i` replaced with `b`,
and thus `cramer A b` is the vector output by Cramer's rule on `A` and `b`.
If `A * x = b` has a unique solution in `x`, `cramer A` sends the vector `b` to `A.det • x`.
Otherwise, the outcome of `cramer` is well-defined but not nece... | true |
WeierstrassCurve.Jacobian.add_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P Q : Fin 3 → F},
W.Nonsingular P → W.Nonsingular Q → P 2 = 0 → Q 2 = 0 → W.add P Q = P 0 ^ 2 • ![1, 1, 0] | null | true |
_private.Mathlib.Order.SupIndep.0.Finset.SupIndep.biUnion._proof_1_1 | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_2} {ι' : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq ι]
{s : Finset ι'} {g : ι' → Finset ι} {f : ι → α} ⦃a : Finset ι⦄,
a ⊆ s.biUnion g →
∀ ⦃b : ι⦄, b ∈ s.biUnion g → b ∉ a → ∀ (i' : ι'), a.sup f ≤ ((s.erase i').biUnion g ∪ (g i').erase b).sup f | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceBoolPred | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Name → ℕ → (Char → Char → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | null | true |
IsAddUnit.eq_add_neg_iff_add_eq | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : SubtractionMonoid α] {a b c : α}, IsAddUnit c → (a = b + -c ↔ a + c = b) | null | true |
ExteriorAlgebra.prodEquivTensorInverse.eq_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Product | ∀ (R : Type u) [inst : CommRing R] (M : Type u_1) (N : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N],
ExteriorAlgebra.prodEquivTensorInverse R M N =
GradedTensorProduct.lift (fun i => ⋀[R]^i M) (fun i => ⋀[R]^i N) (ExteriorAlgebra.map (LinearMap.inl R ... | null | true |
CompleteSemilatticeSup.toPartialOrder | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} → [self : CompleteSemilatticeSup α] → PartialOrder α | null | true |
Continuous.matrix_diagonal | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
[inst_2 : Zero R] [inst_3 : DecidableEq n] {A : X → n → R}, Continuous A → Continuous fun x => Matrix.diagonal (A x) | null | true |
HasSum.congr_fun | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α} {a : α}
{L : SummationFilter β}, HasSum f a L → (∀ (x : β), g x = f x) → HasSum g a L | null | true |
Option.some_eq_dite_none_left._simp_1 | Init.Data.Option.Lemmas | ∀ {β : Type u_1} {a : β} {p : Prop} {x : Decidable p} {b : ¬p → Option β},
(some a = if h : p then none else b h) = ∃ (h : ¬p), some a = b h | null | false |
Bundle.Pretrivialization.symm_trans_symm | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e e' : Bundle.Pretrivialization F proj), (e.symm.trans e'.toPartialEquiv).symm = e'.symm.trans e.toPartialEquiv | null | true |
Aesop.GoalUnsafe.brecOn_5 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
NormedSpace.log | Mathlib.Analysis.Normed.Algebra.Logarithm | {𝔸 : Type u_3} → [inst : Ring 𝔸] → [inst_1 : TopologicalSpace 𝔸] → [IsTopologicalRing 𝔸] → 𝔸 → 𝔸 | `NormedSpace.log : 𝔸 → 𝔸` is the logarithm `log x = ∑ₙ ((-1) ^ (n + 1) / n) • (x - 1) ^ n`.
It is defined as the sum of the `FormalMultilinearSeries` `logSeries ℚ 𝔸` at `x - 1`, in the same
way as `NormedSpace.exp`, and takes the junk value `0` where the series does not converge.
If `𝔸` can't be equipped with a `ℚ... | true |
IsIntCastApply.rec | Mathlib.Algebra.Group.IsApply | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : IntCast F] →
[inst_2 : IntCast β] →
{motive : IsIntCastApply F α β → Sort u} →
((intCast_apply_eq_const : ∀ (n : ℤ) (x : α), ↑n x = ↑n) → motive ⋯) →
(t : IsIntCa... | null | false |
CategoryTheory.IsPullback.hasLiftingProperty | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y Z W : C} {f : X ⟶ Y} {s : X ⟶ Z} {g : Z ⟶ W}
{t : Y ⟶ W},
CategoryTheory.IsPullback s f g t →
∀ {X' Y' : C} (f' : X' ⟶ Y') [CategoryTheory.HasLiftingProperty f' g], CategoryTheory.HasLiftingProperty f' f | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.mem_rootsOfUnity._simp_1_3 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Fin.image_addNat_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n), (fun x => x.addNat m) '' Set.Ioc i j = Set.Ioc (i.addNat m) (j.addNat m) | null | true |
AddSubgroup.isAddCommutative_iSup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Sort u_2} [Nonempty ι] {S : ι → AddSubgroup G}
[hS : ∀ (i : ι), IsAddCommutative ↥(S i)], Directed (fun x1 x2 => x1 ≤ x2) S → IsAddCommutative ↥(⨆ i, S i) | null | true |
List.findM?_pure | Init.Data.List.Control | ∀ {α : Type} {m : Type → Type u_1} [inst : Monad m] [LawfulMonad m] (p : α → Bool) (as : List α),
List.findM? (fun x => pure (p x)) as = pure (List.find? p as) | null | true |
CommRingCat.hom_inv_apply | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommRingCat} (e : R ≅ S) (s : ↑S),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | null | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun'.eq_def | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_1) {α : Type u_4} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (b x : α),
IncidenceAlgebra.muFun'✝ 𝕜 b x =
let a := x;
if a = b then 1
else
-∑ x_1 ∈ (Finset.Ioc a b).attach,
have h := ⋯;
... | null | true |
NumberField.instCommRingAdeleRing._proof_19 | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a : NumberField.AdeleRing R K), a * 1 = a | null | false |
Vector.scanrM.loop.congr_simp | Batteries.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {n : ℕ} [inst : Monad m] (f f_1 : α → β → m β),
f = f_1 →
∀ (as as_1 : Vector α n),
as = as_1 →
∀ (cur cur_1 : β),
cur = cur_1 →
∀ (i : ℕ) (hi : i ≤ n) (acc acc_1 : Vector β (n - i)),
acc = acc_1 → Vector.s... | null | true |
CategoryTheory.Bicategory.leftUnitorNatIso | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
(a b : B) →
(CategoryTheory.Bicategory.precomposing a a b).obj (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.Functor.id (a ⟶ b) | Left unitor as a natural isomorphism. | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularTopology.0.CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi._simp_1_1 | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X), ⊤.1 f = True | null | false |
UniformSpace.mem_ball_comp | Mathlib.Topology.UniformSpace.Defs | ∀ {β : Type ub} {V W : Set (β × β)} {x y z : β},
y ∈ UniformSpace.ball x V → z ∈ UniformSpace.ball y W → z ∈ UniformSpace.ball x (SetRel.comp V W) | The triangle inequality for `UniformSpace.ball` | true |
Qq.Impl.PatternVar.ctorIdx | Qq.Match | Qq.Impl.PatternVar → ℕ | null | false |
Std.ExtHashMap.getD_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → γ} {k : α} {fallback : γ},
(Std.ExtHashMap.map f m).getD k fallback = (Option.map (f k) m[k]?).getD fallback | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.