name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Preadditive.isSeparator_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsSeparator G ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = 0) → f = 0 | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.hasSum_nat_jacobiTheta._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
List.insert_replicate_self | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α},
0 < n → List.insert a (List.replicate n a) = List.replicate n a | true |
Polynomial.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
HasStrictDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x | true |
AlgHom.toOpposite._proof_2 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x * y) = (↑↑(f.toOpposite hf)).toFun x * (↑↑(f.toOpposite h... | false |
Subtype.instTotalLE | Init.Data.Subtype.Order | ∀ {α : Type u} [inst : LE α] [i : Std.Total fun x1 x2 => x1 ≤ x2] {P : α → Prop}, Std.Total fun x1 x2 => x1 ≤ x2 | true |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.mk_eq_bot._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, (r₁ = r₂) = (⇑r₁ = ⇑r₂) | false |
InverseSystem.piSplitLE._proof_14 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {i : ι} [inst : PartialOrder ι], i ≤ i | false |
InnerProductSpace.toDual_apply_eq_toDualMap_apply | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (x : E), (InnerProductSpace.toDual 𝕜 E) x = (InnerProductSpace.toDualMap 𝕜 E) x | true |
SimpleGraph.Subgraph.coeCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {G : SimpleGraph V} → (G' : G.Subgraph) → G'.coe.Copy G | true |
SimpleGraph.map_neighborFinset_induce_of_neighborSet_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj] {v : ↑s},
G.neighborSet ↑v ⊆ s →
Finset.map (Function.Embedding.subtype fun x => x ∈ s) ((SimpleGraph.induce s G).neighborFinset v) =
G.neighborFinset ↑v | true |
Polynomial.eraseLead_monomial | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), ((Polynomial.monomial i) r).eraseLead = 0 | true |
AddSemiconjBy.unop | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {a x y : αᵃᵒᵖ},
AddSemiconjBy a x y → AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) | true |
Equiv.sigmaSumDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (p : (i : ι) × (α i ⊕ β i)),
(Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd | true |
Num.mod.eq_3 | Mathlib.Data.Num.ZNum | ∀ (a b : PosNum), (Num.pos a).mod (Num.pos b) = a.mod' b | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_726 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.card + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.c... | false |
CategoryTheory.Limits.prod.map_mono | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] [inst_3 : CategoryTheory.Limits.HasBinaryProduct W X]
[inst_4 : CategoryTheory.Limits.HasBinaryProduct Y Z], CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g) | true |
List.step_iter_cons | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {x : β} {xs : List β}, (x :: xs).iter.step = ⟨Std.IterStep.yield xs.iter x, ⋯⟩ | true |
CategoryTheory.Square.toArrowArrowFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp φ.τ₂ Y.f₂₄ = CategoryTheory.CategoryStruct.comp X.f₂₄ φ.τ₄ | false |
tacticSimp_wf | Init.WFTactics | Lean.ParserDescr | true |
preservesBinaryCoproducts_of_preservesInitial_and_pushouts | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) F]
[... | true |
MeasureTheory.measureReal_union_null | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
μ.real s₁ = 0 → μ.real s₂ = 0 → μ.real (s₁ ∪ s₂) = 0 | true |
Polynomial.C_mul_X_pow_eq_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a | true |
LeanSearchClient.LoogleResult.noConfusionType | LeanSearchClient.LoogleSyntax | Sort u → LeanSearchClient.LoogleResult → LeanSearchClient.LoogleResult → Sort u | false |
MvPolynomial.isWeightedHomogeneous_X | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (i : σ),
MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i) | true |
TopologicalLattice.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Lattice L] →
{motive : TopologicalLattice L → Sort u} →
([toContinuousInf : ContinuousInf L] → [toContinuousSup : ContinuousSup L] → motive ⋯) →
(t : TopologicalLattice L) → motive t | false |
MeasureTheory.FiniteMeasure.restrict_biUnion_finset | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_3} {μ : MeasureTheory.FiniteMeasure Ω} {T : Finset ι}
{s : ι → Set Ω},
(↑T).Pairwise (Function.onFun Disjoint s) →
(∀ (i : ι), MeasurableSet (s i)) → μ.restrict (⋃ i ∈ T, s i) = ∑ i ∈ T, μ.restrict (s i) | true |
Prod.mk_le_swap._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x : α × β} {a : α} {b : β},
((b, a) ≤ x.swap) = ((a, b) ≤ x) | false |
Similar.comp_left_iff | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₁ P₃] [DilationClass F P₁ P₃] (f : F), Similar (⇑f ∘ v₁) v₂ ↔ Similar v₁ v₂ | true |
List.set | Init.Prelude | {α : Type u_1} → List α → ℕ → α → List α | true |
DoResultPRBC.recOn | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) →
((a : α) → (a_1 : σ) → motive (DoResultPRBC.pure a a_1)) →
((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) →
((a : σ) → motive (DoResultPRBC.break a)) → ((a : σ) → motive (DoResultPRBC.conti... | false |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | (R : Type (u + 1)) →
[inst : Ring R] →
(F : CategoryTheory.Functor Profiniteᵒᵖ (ModuleCat R)) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
CategoryTheory.regularTopology.EqualizerCondition F → CondensedMod R | true |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u →
{J : CategoryTheory.Limits.MultispanShape} →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
x.Hom x_1 →
{J' : CategoryTheory.Limits.MultispanShape} →
{x' x'_1 : CategoryTheory.Limits.WalkingMultispan J'} → x'.Hom x'_1 → Sort u | false |
CochainComplex.homologyMap_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | false |
MeasureTheory.Integrable.bdd_mul' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_8} [inst : NormedRing 𝕜]
{f g : α → 𝕜} {c : ℝ},
MeasureTheory.Integrable g μ →
MeasureTheory.AEStronglyMeasurable f μ →
(∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c) → MeasureTheory.Integrable (fun x => f x * g x) μ | true |
lt_iff_le_and_ne' | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, b < a ↔ b ≤ a ∧ a ≠ b | true |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
[∀ (i : ι), WellFoundedLT (α i)], (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0) → WellFoundedLT (Π₀ (i : ι), α i) | true |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ) (h : n = 0)
(X : CochainComplex C ℤ) (i : ℤ),
((CochainComplex.shiftFunctorZero' C n h).inv.app X).f i = (HomologicalComplex.XIsoOfEq X ⋯).inv | true |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M} (h : S = T),
MulEquiv.submonoidCongr h = { toEquiv := Equiv.setCongr ⋯, map_mul' := ⋯ } | true |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (B : Rep.{u, u, u} k H),
Rep.coinvariantsTensorIndHom φ A B =
ModuleCat.ofHom
(Representation.Coinvariants.lift
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u, u, ... | true |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | Sort u →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
{L : CategoryTheory.Functor A T} →
{R : ... | false |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | false |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | ∀ {a : Prop}, (¬¬a) = a | false |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type w} →
{R : Type u} →
[inst : Semiring R] →
{M : Type v} → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {v : ι → M} → LinearIndependent R v → Prop | true |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), ⊥ ≤ t | false |
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | {n : ℕ} →
(α : Fin (n + 1) → Type u_2) →
[inst : (i : Fin (n + 1)) → LE (α i)] → α (Fin.last n) × ((i : Fin n) → α i.castSucc) ≃o ((i : Fin (n + 1)) → α i) | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
x ≈ x_1 →
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x =
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x_1 | false |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | Lean.TSyntax [`ident, `num] → Array Lean.Name → Array Lean.Expr → Lean.MessageData → Lean.MetaM ℕ | true |
ContinuousLinearMapWOT.instAddCommGroup._aux_14 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
{σ : 𝕜₁ →+* 𝕜₂} →
{E : Type u_3} →
{F : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E... | false |
CategoryTheory.AddMonObj.ofIso | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M X : C} → [CategoryTheory.AddMonObj M] → (M ≅ X) → CategoryTheory.AddMonObj X | true |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | {α : Type u_1} →
{f : Filter α} →
{motive : f.Realizer → Sort u} →
((σ : Type u_5) → (F : CFilter (Set α) σ) → (eq : F.toFilter = f) → motive { σ := σ, F := F, eq := eq }) →
(t : f.Realizer) → motive t | false |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | Lean.Meta.ParamInfo → Bool | true |
Lean.Server.FileWorker.FileSetupResult.ctorElim | Lean.Server.FileWorker.SetupFile | {motive : Lean.Server.FileWorker.FileSetupResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Server.FileWorker.FileSetupResult) →
ctorIdx = t.ctorIdx → Lean.Server.FileWorker.FileSetupResult.ctorElimType ctorIdx → motive t | false |
instSemilatticeSupPrimeMultiset._proof_5 | Mathlib.Data.PNat.Factors | ∀ (a b c : PrimeMultiset), a ≤ c → b ≤ c → instSemilatticeSupPrimeMultiset._aux_1 a b ≤ c | false |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} [inst : MulZeroOneClass α] {β : Type u_2} [inst_1 : CommMonoidWithZero β], MonoidHomClass (α →*₀ β) α β | false |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X : C} (f : c.pt ⟶ X), (c.extend f).pt = X | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) = (p < n) | false |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : SetRel α α), (hausdorffEntourage U).inv = hausdorffEntourage U.inv | true |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a * b = 1 → a⁻¹ = b | true |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_5} {σ : Type u_6} [inst : CommRing R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → (-φ).IsHomogeneous n | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | Lean.Name → Array Lean.Name → Option Lean.Name | true |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{X Y : C} →
(f : Y ⟶ X) →
(motive : (CategoryTheory.Sieve.generateSingleton f).arrows.category → Sort u_3) →
(x : (CategoryTheory.Sieve.generateSingleton f).arrows.category) →
((obj : CategoryTheory.Over X) →
... | false |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Semiring R], IsField R → ¬0 = 0 → ∃ b, 0 * b = 1 | false |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | Lean.FVarId → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit | true |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [MOD n] → b < n → a % n = b | true |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | ℕ → ℕ → ℕ | true |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive : CategoryTheory.Limits.WalkingParallelFamily J → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelFamily J) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelFamily.one → motive t | false |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | {V : Type u_1} →
{W : Type u_2} →
[inst : AddCommGroup V] →
[inst_1 : Module ℝ V] →
[inst_2 : TopologicalSpace V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module ℝ W] →
[inst_5 : TopologicalSpace W] →
{e : AddChar ℝ Circle} →
{L : ... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) | true |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) {M : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
IsScalarTower A A M | false |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C)
{X x : CategoryTheory.Cokleisli U} (f : X ⟶ x),
(CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).map f =
CategoryTheory.CategoryStruct.comp (U.δ.app X.of) (U.map f.of) | true |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {S : Submonoid Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_32 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt64), 1 * a = a | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (X i)},
s.pi t = s.pi fun i => if i ∈ s then t i else Set.univ | false |
NNReal.coe_inv._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r : NNReal), (↑r)⁻¹ = ↑r⁻¹ | false |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.find? p l = (List.dropWhile (fun x => !p x) l).head? | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), (a.comp a_1 = a_2.comp a_3) = (a = a_2 ∧ a_1 = a_3) | true |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | Lean.Macro | false |
HAnd.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HAnd α β γ → Sort u_1} → ((hAnd : α → β → γ) → motive { hAnd := hAnd }) → (t : HAnd α β γ) → motive t | false |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
s ⊆ ↑(Algebra.adjoin R s) | true |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(s t : TopologicalSpace.CompactOpens α), ↑s ⇨ ↑t = ↑(s ⇨ t) | false |
floorDiv_of_nonpos | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : SMulZeroClass α β] [inst_5 : FloorDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌊/⌋ a = 0 | true |
Std.ExtTreeMap.getElem_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
{f : β → β} {hc : k' ∈ t.modify k f}, (t.modify k f)[k'] = if heq : cmp k k' = Ordering.eq then f t[k] else t[k'] | true |
hasDerivAtFilter_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {L : Filter (𝕜 × 𝕜)},
HasDerivAtFilter f f' L ↔ Filter.Tendsto (fun p => ‖p.1 - p.2‖⁻¹ * ‖f p.1 - f p.2 - (p.1 - p.2) • f'‖) L (nhds 0) | true |
_private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.dickson.match_1.eq_1 | Mathlib.RingTheory.Polynomial.Dickson | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ.succ => h_3 n) =
h_1 () | true |
MeasureTheory.Measure.restrict_toOuterMeasure_eq_toOuterMeasure_restrict | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ.restrict s).toOuterMeasure = (MeasureTheory.OuterMeasure.restrict s) μ.toOuterMeasure | true |
Lean.LOption.some.sizeOf_spec | Lean.Data.LOption | ∀ {α : Type u} [inst : SizeOf α] (a : α), sizeOf (Lean.LOption.some a) = 1 + sizeOf a | true |
_private.Mathlib.Algebra.Notation.Support.0.Function.mulSupport_curry._simp_1_1 | Mathlib.Algebra.Notation.Support | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
IsLocalization.isRegular_mk'._simp_1 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S],
(∀ m ∈ M, IsRegular m) → ∀ {r : R} {m : ↥M}, IsRegular (IsLocalization.mk' S r m) = IsRegular r | false |
Set.insert_prod | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α}, insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t | true |
CategoryTheory.InjectiveResolution.instInjectiveXIntCochainComplex | Mathlib.CategoryTheory.Abelian.Injective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {X : C} (R : CategoryTheory.InjectiveResolution X) (n : ℤ),
CategoryTheory.Injective (R.cochainComplex.X n) | true |
SheafOfModules.GeneratingSections.IsFiniteType.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddC... | true |
CategoryTheory.GrothendieckTopology.diagramFunctor_map | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (D : Type w)
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(X : C) {X_1 Y : CategoryT... | true |
ProfiniteAddGrp.recOn | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {motive : ProfiniteAddGrp.{u} → Sort u_1} →
(t : ProfiniteAddGrp.{u}) →
((toProfinite : Profinite) →
[addGroup : AddGroup ↑toProfinite.toTop] →
[topologicalAddGroup : IsTopologicalAddGroup ↑toProfinite.toTop] →
motive { toProfinite := toProfinite, addGroup := addGroup, topologicalAdd... | false |
ContinuousEval.toContinuousEvalConst | Mathlib.Topology.Hom.ContinuousEval | ∀ {F : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : FunLike F X Y] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace Y] [ContinuousEval F X Y], ContinuousEvalConst F X Y | true |
Perfection.coeffMonoidHom_pow_p_pow_self | Mathlib.RingTheory.Perfection | ∀ {M : Type u_1} [inst : CommMonoid M] {p : ℕ} (f : Perfection M p) (n : ℕ),
(Perfection.coeffMonoidHom M p n) f ^ p ^ n = (Perfection.coeffMonoidHom M p 0) f | true |
AddSubmonoid.mk._flat_ctor | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
(carrier : Set M) → (∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) → 0 ∈ carrier → AddSubmonoid M | false |
MulAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {N : Subgroup G} [N.Normal] (a : X),
MulAction.IsBlock G (MulAction.orbit (↥N) a) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.