name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Poly.instOne | Mathlib.NumberTheory.Dioph | {α : Type u_1} → One (Poly α) | 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 |
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 |
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 |
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 |
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 |
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 |
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 |
_private.Std.Time.Format.Basic.0.Std.Time.formatWith.match_35 | Std.Time.Format.Basic | (motive : (format : Std.Time.ZoneName) → Std.Time.TypeFormat (Std.Time.Modifier.v format) → Sort u_1) →
(format : Std.Time.ZoneName) →
(data : Std.Time.TypeFormat (Std.Time.Modifier.v format)) →
((data : Std.Time.TypeFormat (Std.Time.Modifier.v Std.Time.ZoneName.short)) →
motive Std.Time.ZoneName.... | 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 |
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 ≅ ↧(DirectSum ι fun i => ↑(Z i)) | The categorical coproduct of a family of objects in `ModuleCat`
agrees with direct sum.
| true |
IccRightChart_apply | Mathlib.Geometry.Manifold.Instances.Real | ∀ {x y : ℝ} [hxy : Fact (x < y)] (z : ↑(Set.Icc x y)), ↑(IccRightChart x y) z = ⟨WithLp.toLp 2 fun x_1 => y - ↑z, ⋯⟩ | null | true |
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 |
_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 |
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 |
instDecidableEqZNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬ZNum.zero = ZNum.neg a | null | false |
ImportGraph.Shake.instBEqDeclDeclNeedsKind | ImportGraph.Shake.DeclNeeds | BEq ImportGraph.Shake.DeclDeclNeedsKind | 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 |
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 |
NormedAddGroup.ofSeparation.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_2} [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 |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.mkSimpOnly.match_3 | Lean.Elab.Tactic.Simp | (motive : Bool → Sort u_1) → (post : Bool) → (Unit → motive true) → (Unit → motive false) → motive post | null | false |
TopologicalSpace.gciGenerateFrom._proof_3 | Mathlib.Topology.Order | ∀ (α : Type u_1) (x : (Set (Set α))ᵒᵈ) (x_1 : x ≤ OrderDual.toDual {s | IsOpen s}),
TopologicalSpace.mkOfClosure x ⋯ = TopologicalSpace.generateFrom x | null | false |
RBTree.RBNode.Path.listR.eq_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1}, RBTree.RBNode.Path.root.listR = [] | null | true |
Subsemiring.toSemiring._proof_9 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : Semiring R] (s : Subsemiring R) (a b c : ↥s), (a + b) * c = a * c + b * c | null | false |
AddCommGroup.freeRank_eq_zero | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommGroup G], IsAddTorsion G → ∀ [inst_1 : AddGroup.FG G], AddCommGroup.freeRank G = 0 | null | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.isNatProp._sparseCasesOn_2 | Mathlib.Tactic.Linarith.Preprocessing | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Lean.CasesAltInfo.noConfusionType | Lean.Meta.CasesInfo | Sort u → Lean.CasesAltInfo → Lean.CasesAltInfo → Sort u | null | false |
Std.Http.Internal.Char.isValidSchemeChar | Std.Http.Internal.Char | Char → Bool | Checks if a character is valid after the first character of a URI scheme.
Valid characters are ASCII alphanumeric, `+`, `-`, and `.`.
| true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.uncons? | Batteries.Data.MLList.Basic | {m : Type u → Type u} →
(self : MLList.Spec✝ m) → {α : Type u} → MLList.Spec.listM✝ self α → Option (Option (α × MLList.Spec.listM✝ self α)) | null | true |
ChainComplex.mk'_congr_succ'_d._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(succ' : {X₀ X₁ : V} → (f : X₁ ⟶ X₀) → (X₂ : V) ×' (d : X₂ ⟶ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0)
{X Y : V} (f g : X ⟶ Y), f = g → (succ' f).fst = (succ' g).fst | null | false |
MeasureTheory.isTightMeasureSet_of_forall_basis_tendsto | Mathlib.MeasureTheory.Measure.TightNormed | ∀ {E : Type u_1} {mE : MeasurableSpace E} {S : Set (MeasureTheory.Measure E)} [inst : NormedAddCommGroup E]
{𝕜 : Type u_2} {ι : Type u_3} [inst_1 : RCLike 𝕜] [inst_2 : Fintype ι] [inst_3 : InnerProductSpace 𝕜 E]
[FiniteDimensional 𝕜 E] (b : OrthonormalBasis ι 𝕜 E),
(∀ (i : ι), Filter.Tendsto (fun r => ⨆ μ ∈ ... | null | true |
CategoryTheory.MorphismProperty.wrapped._@.Mathlib.CategoryTheory.Localization.LocallySmall.315190127._hygCtx._hyg.8 | Mathlib.CategoryTheory.Localization.LocallySmall | Subtype (Eq @CategoryTheory.MorphismProperty.definition✝) | null | false |
Lean.Meta.addToCompletionBlackList | Lean.Meta.CompletionName | Lean.Environment → Lean.Name → Lean.Environment | null | true |
_private.Mathlib.RingTheory.DedekindDomain.SelmerGroup.0.IsDedekindDomain.selmerGroup.fromUnit_ker._simp_1_1 | Mathlib.RingTheory.DedekindDomain.SelmerGroup | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) | null | false |
Order.sequenceOfCofinals.match_3 | Mathlib.Order.Ideal | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
neg_iff_neg_of_smul_pos | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : LinearOrder α] [inst_4 : LinearOrder β] [PosSMulMono α β] [SMulPosMono α β], 0 < a • b → (a < 0 ↔ b < 0) | null | true |
Lean.Elab.Command.mkInstanceName | Lean.Elab.DeclNameGen | Array Lean.Syntax → Lean.Syntax → Lean.Elab.Command.CommandElabM Lean.Name | Generates an instance name for a declaration that has the given binders and type.
It tries to make these names relatively unique ecosystem-wide.
Note that this elaborates the binders and the type.
This means that when elaborating an instance declaration, we elaborate these twice.
| true |
SimpleGraph.ConnectedComponent.reachable_toSimpleGraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent) {u v : V} (hu : u ∈ C) (hv : v ∈ C),
C.toSimpleGraph.Reachable ⟨u, hu⟩ ⟨v, hv⟩ | There is a walk between every pair of vertices in a connected component. | true |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.Scheme.Hom.map_resLE._simp_1_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {V V' : X.Opens} (i : V ≤ V'),
X.homOfLE i = AlgebraicGeometry.Scheme.Hom.resLE (CategoryTheory.CategoryStruct.id X) V' V i | null | false |
Lean.Compiler.LCNF.Simp.ConstantFold.instLiteralNat | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Compiler.LCNF.Simp.ConstantFold.Literal ℕ | null | true |
SeparationQuotient.instNonUnitalNonAssocCommSemiring | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocCommSemiring R] →
[IsTopologicalSemiring R] → NonUnitalNonAssocCommSemiring (SeparationQuotient R) | null | true |
Polynomial.roots_X_add_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] (r : R), (Polynomial.X + Polynomial.C r).roots = {-r} | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._simp_1_4 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] [Nonempty α] {s : Set α},
(s ∈ Filter.atTop) = ∃ a, ∀ (b : α), a ≤ b → b ∈ s | null | false |
Set.Ici.complementedLattice_iff | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : Lattice α] [inst_1 : OrderTop α],
ComplementedLattice ↑(Set.Ici a) ↔ ∀ (b : α), a ≤ b → ∃ c, a ≤ c ∧ b ⊔ c = ⊤ ∧ b ⊓ c = a | null | true |
GrpCat.recOn | Mathlib.Algebra.Category.Grp.Basic | {motive : GrpCat → Sort u_1} →
(t : GrpCat) → ((carrier : Type u) → [str : Group carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
CategoryTheory.Lax.StrongTrans.naturality_comp._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Lean.Syntax | null | false |
HomotopicalAlgebra.FibrantBrownFactorization.ctorIdx | Mathlib.AlgebraicTopology.ModelCategory.BrownLemma | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : HomotopicalAlgebra.ModelCategory C} →
{X Y : C} → {f : X ⟶ Y} → HomotopicalAlgebra.FibrantBrownFactorization f → ℕ | null | false |
Finset.smulCommClass | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : SMul α γ] [inst_2 : SMul β γ]
[SMulCommClass α β γ], SMulCommClass (Finset α) (Finset β) (Finset γ) | null | true |
Nat.div_le_div_right | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a ≤ b → a / c ≤ b / c | null | true |
AddConGen.Rel.below.rec | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {r : M → M → Prop} {motive : (a a_1 : M) → AddConGen.Rel r a a_1 → Prop}
{motive_1 : {a a_1 : M} → (t : AddConGen.Rel r a a_1) → AddConGen.Rel.below t → Prop},
(∀ (x y : M) (a : r x y), motive_1 ⋯ ⋯) →
(∀ (x : M), motive_1 ⋯ ⋯) →
(∀ {x y : M} (a : AddConGen.Rel r x y) (ih :... | null | false |
Nat.factorial_one | Mathlib.Data.Nat.Factorial.Basic | Nat.factorial 1 = 1 | null | true |
Polynomial.toContinuousMapAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Polynomial | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [inst_2 : IsTopologicalSemiring R] (x : R),
((algebraMap R (Polynomial R)) x).toContinuousMap = (algebraMap R C(R, R)) x | null | false |
Module.Basis.finTwoProd.eq_1 | Mathlib.LinearAlgebra.Basis.Fin | ∀ (R : Type u_7) [inst : Semiring R],
Module.Basis.finTwoProd R = Module.Basis.ofEquivFun (LinearEquiv.finTwoArrow R R).symm | null | true |
TopCat.Presheaf.isSheafOpensLeCover_iff_isSheafPairwiseIntersections | Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : TopCat} (F : TopCat.Presheaf C X),
F.IsSheafOpensLeCover ↔ F.IsSheafPairwiseIntersections | The sheaf condition
in terms of a limit diagram over all `{ V : Opens X // ∃ i, V ≤ U i }`
is equivalent to the reformulation
in terms of a limit diagram over `U i` and `U i ⊓ U j`.
| true |
Cardinal.IsStrongLimit.casesOn | Mathlib.SetTheory.Cardinal.Order | {c : Cardinal.{u_1}} →
{motive : c.IsStrongLimit → Sort u} →
(t : c.IsStrongLimit) → ((ne_zero : c ≠ 0) → (isStrongPrelimit : c.IsStrongPrelimit) → motive ⋯) → motive t | null | false |
AddSubgroup.comap_injective_isAddCommutative | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) {f : G' →+ G},
Function.Injective ⇑f → ∀ [IsAddCommutative ↥H], IsAddCommutative ↥(AddSubgroup.comap f H) | null | true |
Lean.Elab.Term.mkCalcFirstStepView | Lean.Elab.Calc | Lean.TSyntax `Lean.calcFirstStep → Lean.Elab.TermElabM Lean.Elab.Term.CalcStepView | null | true |
CategoryTheory.Limits.coprod.inr_desc_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct X Y] (f : X ⟶ W) (g : Y ⟶ W) {Z : C} (h : W ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inr
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.desc f... | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_72 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (state : Std.Sat.AIG.toCNF.State✝ aig)
(cond ifTrue ifFalse : Std.Sat.AIG.Fanin) (hltc : cond.gate < upper) (fstate : Std.Sat.AIG.toCNF.State✝ aig),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state fstate cond.gate ⋯ →
∀ (ret : Std.Sat.AIG.toCNF.State... | null | false |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology.match_1 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} (c : Set (Set (Set X))) (motive : c.Nonempty → Prop) (x : c.Nonempty),
(∀ (hne : c.Nonempty) (x : Set (Set X)) (hxc : x ∈ c) (h : hne = ⋯), motive ⋯) → motive x | null | false |
_private.Mathlib.Algebra.Order.Field.Power.0.zpow_eq_neg_zpow_iff₀._simp_1_4 | Mathlib.Algebra.Order.Field.Power | ∀ (n : ℕ), Int.negSucc n = -↑n.succ | null | false |
_private.Lean.SubExpr.0.Lean.Expr.traverseAppWithPos._sparseCasesOn_1 | Lean.SubExpr | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
ZMod.differentiableAt_LFunction | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] (Φ : ZMod N → ℂ) (s : ℂ), s ≠ 1 ∨ ∑ j, Φ j = 0 → DifferentiableAt ℂ (ZMod.LFunction Φ) s | null | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._proof_1_3 | Mathlib.Data.Int.Interval | ∀ (m n : ℕ) (a : ℤ), ¬(-(↑m + 1) ≤ a ∧ a < ↑n + 1 ↔ a = -(↑m + 1) ∨ a = ↑n ∨ -↑m ≤ a ∧ a < ↑n) → False | null | false |
_private.Mathlib.GroupTheory.GroupAction.Jordan.0.Equiv.Perm.alternatingGroup_le_of_isPreprimitive_of_isThreeCycle_mem._simp_1_6 | Mathlib.GroupTheory.GroupAction.Jordan | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {x : α},
(x ∈ SubMulAction.ofFixingSubgroup M s) = (x ∉ s) | null | false |
_private.Mathlib.Computability.Ackermann.0.ack.match_1.eq_1 | Mathlib.Computability.Ackermann | ∀ (motive : ℕ → ℕ → Sort u_1) (n : ℕ) (h_1 : (n : ℕ) → motive 0 n) (h_2 : (m : ℕ) → motive m.succ 0)
(h_3 : (m n : ℕ) → motive m.succ n.succ),
(match 0, n with
| 0, n => h_1 n
| m.succ, 0 => h_2 m
| m.succ, n.succ => h_3 m n) =
h_1 n | null | true |
Filter.EventuallyLE.of_le | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : LE β] {l : Filter α} {f g : α → β}, f ≤ g → f ≤ᶠ[l] g | **Alias** of `LE.le.eventuallyLE`. | true |
Submodule.unitsToPic_apply | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) (A : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] (I : (Submodule R A)ˣ), (Submodule.unitsToPic R A) I = CommRing.Pic.mk R ↥↑I | null | true |
lp.norm_zero | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_3} {E : α → Type u_4} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)], ‖0‖ = 0 | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go_get_aux._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract | ∀ {newWidth : ℕ}, ∀ curr ≤ newWidth, ∀ idx < curr, idx < newWidth | null | false |
PositiveLinearMap.instModuleComplexPreGNS._aux_1 | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} →
[inst : NonUnitalRing A] → [inst_1 : PartialOrder A] → [inst_2 : Module ℂ A] → (f : A →ₚ[ℂ] ℂ) → SMul ℂ f.PreGNS | null | false |
instRingObjOppositeOpensCarrierOfPresheafSmoothSheaf._proof_18 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.getImportCandidates | Mathlib.Tactic.ClickSuggestions.TryPremises | Mathlib.Tactic.ClickSuggestions.RwInfo →
Array Mathlib.Tactic.ClickSuggestions.GrwPos →
(String → BaseIO Unit) →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Array Mathlib.Tactic.ClickSuggestions.Candidates✝) | Get the candidate theorems from imported files. | true |
Set.op_vadd_set_subset_add | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] {s t : Set α} {a : α}, a ∈ t → AddOpposite.op a +ᵥ s ⊆ s + t | null | true |
MeasureTheory.SignedMeasure.totalVariation.eq_1 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α),
s.totalVariation = s.toJordanDecomposition.posPart + s.toJordanDecomposition.negPart | null | true |
MeasureTheory.IsStoppingTime.measurableSet_le | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{τ : Ω → WithTop ι}, MeasureTheory.IsStoppingTime f τ → ∀ (i : ι), MeasurableSet {ω | τ ω ≤ ↑i} | null | true |
ClosedSubmodule.map_le_iff_le_comap | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : TopologicalSpace M] [inst_3 : Module R M] [inst_4 : AddCommMonoid N] [inst_5 : TopologicalSpace N]
[inst_6 : Module R N] [inst_7 : ContinuousAdd N] [inst_8 : ContinuousConstSMul R N] {f : M →L[R] N}
{s : Closed... | null | true |
Lean.Lsp.HighlightMatchesOptions._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.HighlightMatchesOptions | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Real.rpow_zpow_comm._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ (x : ℝ) (n : ℤ), x ^ n = x ^ ↑n | null | false |
_private.Lean.Compiler.LCNF.Level.0.Lean.Compiler.LCNF.NormLevelParam.normExpr._sparseCasesOn_1 | Lean.Compiler.LCNF.Level | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((declName : Lean.Name) →
(type value b... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataT'Aux.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U V W U₀ : ↑X.affineOpens) (hU₀ : ↑U ⊓ ↑W ≤ ↑U₀),
I.glueDataT'Aux U V W U₀ hU₀ = I.glueDataT'Aux U V W U₀ hU₀ | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.UnicodeLinter.findBadUnicodeAux.match_1.eq_1 | Mathlib.Tactic.Linter.TextBased | ∀ (motive : Option Char → Sort u_1) (h_1 : Unit → motive none) (h_2 : (cₙ : Char) → motive (some cₙ)),
(match none with
| none => h_1 ()
| some cₙ => h_2 cₙ) =
h_1 () | null | true |
Polynomial.hasFDerivAt_aeval | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R 𝕜]
(q : Polynomial R) (x : 𝕜),
HasFDerivAt (fun x => (Polynomial.aeval x) q)
(ContinuousLinearMap.smulRight 1 ((Polynomial.aeval x) (Polynomial.derivative q))) x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.