name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finsupp.subtypeDomain_extendDomain | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_12} [inst : Zero M] {P : α → Prop} [inst_1 : DecidablePred P] (f : Subtype P →₀ M),
Finsupp.subtypeDomain P f.extendDomain = f | true |
ContinuousAlternatingMap.bounds_nonempty | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] {f : E [⋀^ι]→L[𝕜] F},
∃ c, c ∈ {c | 0 ≤ c ∧ ∀ (m : ι → E), ‖f m‖ ≤ c * ... | true |
ENNReal.instCompleteLinearOrder._aux_1 | Mathlib.Data.ENNReal.Basic | Set ENNReal → ENNReal | false |
_private.Mathlib.Tactic.MinImports.0.Mathlib.Command.MinImports.previousInstName.match_5 | Mathlib.Tactic.MinImports | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((nm init : Lean.Name) → (tail : String) → (h : nm = init.str tail) → motive (namedPattern nm (init.str tail) h)) →
((nm : Lean.Name) → motive nm) → motive x | false |
Std.Internal.List.minKey_insertEntryIfNew_le_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k} {he : l.isEmpty = false},
(compare (Std.Internal.List.minKey (Std.Internal.List.insertEntryIfNew k v l) ⋯)
(S... | true |
FirstOrder.Language.Structure.noConfusionType | Mathlib.ModelTheory.Basic | Sort u_1 →
{L : FirstOrder.Language} →
{M : Type w} → L.Structure M → {L' : FirstOrder.Language} → {M' : Type w} → L'.Structure M' → Sort u_1 | false |
CategoryTheory.Limits.prod.lift' | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W X Y : C} →
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y] →
(f : W ⟶ X) →
(g : W ⟶ Y) →
{ l //
CategoryTheory.CategoryStruct.comp l CategoryTheory.Limits.prod.fst = f ∧
CategoryTh... | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_9 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (hs : table.size < pat.utf8ByteSize),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun table ht₀ =>
PSigma.casesOn ht₀ fun ht₀ ht =... | false |
Subalgebra.prod_toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (S : Subalgebra R A) (S₁ : Subalgebra R B),
Subalgebra.toSubmodule (S.prod S₁) = (Subalgebra.toSubmodule S).prod (Subalgebra.toSubmodule S₁) | true |
CategoryTheory.bifunctorComp₁₂ | Mathlib.CategoryTheory.Functor.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{C₁₂ : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_... | true |
Std.Tactic.BVDecide.BVUnOp.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVUnOp → Sort u} →
(t : Std.Tactic.BVDecide.BVUnOp) →
motive Std.Tactic.BVDecide.BVUnOp.not →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateLeft n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.BVUnOp.rotateRight n)) →
((n : ℕ) → motive (Std.Tactic.BVDecide.... | false |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState.mk | Lean.Elab.DocString | Lean.Doc.State →
Array (Lean.ScopedEnvExtension Lean.EnvExtensionEntry Lean.EnvExtensionEntry Lean.EnvExtensionState) →
Lean.Doc.ModuleDocstringState✝ | true |
Tree._sizeOf_inst | Mathlib.Data.Tree.Basic | (α : Type u) → [SizeOf α] → SizeOf (Tree α) | false |
_private.Mathlib.Data.Real.ConjExponents.0.ENNReal.HolderTriple.toNNReal_iff._simp_1_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, p.HolderTriple q r = (↑p).HolderTriple ↑q ↑r | false |
Monoid.Coprod.mk | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} →
{N : Type u_2} → [inst : MulOneClass M] → [inst_1 : MulOneClass N] → FreeMonoid (M ⊕ N) →* Monoid.Coprod M N | true |
MeasurableSMul₂ | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → (α : Type u_3) → [SMul M α] → [MeasurableSpace M] → [MeasurableSpace α] → Prop | true |
CategoryTheory.Abelian.SpectralObject.isIso_map_fourδ₄Toδ₃._auto_5 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax | false |
TensorProduct.instRepr | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{M : Type u_7} →
{N : Type u_8} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → [Repr M] → [Repr N] → Repr (TensorProduct R M N) | true |
CategoryTheory.ShortComplex.Hom.mk.sizeOf_spec | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : SizeOf C] (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂)
(τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ :
autoParam (CategoryTheory.CategoryStruct.comp τ₁ S₂.f = Catego... | true |
Aesop.GoalStats.forwardStateStats | Aesop.Stats.Basic | Aesop.GoalStats → Aesop.ForwardStateStats | true |
Polynomial.eval_le_zero_of_roots_le_of_leadingCoeff_nonpos | Mathlib.Analysis.Polynomial.Order | ∀ {P : Polynomial ℝ} {x : ℝ}, (∀ (y : ℝ), P.IsRoot y → y ≤ x) → P.leadingCoeff ≤ 0 → Polynomial.eval x P ≤ 0 | true |
LieAlgebra.IsKilling.corootSubmodule._proof_2 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_1} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] {H : LieSubalgebra K L},
AddSubmonoidClass (LieSubmodule K (↥H) L) L | false |
ByteArray.size_set | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size) (v : UInt8), (a.set (↑i) v ⋯).size = a.size | true |
Homeomorph.instEquivLike._proof_2 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (h : X ≃ₜ Y),
Function.RightInverse h.invFun h.toFun | false |
CompHaus.toStonean | Mathlib.Topology.Category.Stonean.Basic | (X : CompHaus) → [CategoryTheory.Projective X] → Stonean | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.mk.sizeOf_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} [inst_1 : SizeOf K]
(a b c : NumberField.RingOfIntegers K) (u : (NumberField.RingOfIntegers K)ˣ) (ha : ¬hζ.toInteger - 1 ∣ a)
(hb : ¬hζ.toInteger - 1 ∣ b) (hc : c ≠ 0) (coprime : IsCoprime a b) (hcdvd : hζ.toInteger - 1 ∣ c)
(H : a ^ 3 + b ^ 3 =... | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.oppositeLeftAction_actionHom_op | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' : C} {d d' : D} (f : c ⟶ c') (g : d ⟶ d'),
CategoryTheory.MonoidalCateg... | true |
add_neg' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftMono α] {a b : α}, a < 0 → b < 0 → a + b < 0 | true |
Complex.arg_cos_add_sin_mul_I | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {θ : ℝ}, θ ∈ Set.Ioc (-Real.pi) Real.pi → (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg = θ | true |
biUnion_associatedPrimes_eq_zero_divisors | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsNoetherianRing R], ⋃ p ∈ associatedPrimes R M, ↑p = {r | ∃ x, x ≠ 0 ∧ r • x = 0} | true |
Bundle.Pretrivialization.restrictPreimage'._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {Z : Type u_1} {proj : Z → B} (s : Set B) (z : ↑(proj ⁻¹' s)), ↑z ∈ proj ⁻¹' s | false |
CategoryTheory.MorphismProperty.LeftFraction.ofHom.eq_1 | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities],
CategoryTheory.MorphismProperty.LeftFraction.ofHom W f =
{ Y' := Y, f := f, s := CategoryTheory.CategoryStruct.id Y, hs := ⋯ } | true |
Set.countable_union | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Countable ↔ s.Countable ∧ t.Countable | true |
Int.Linear.cooper_right_split_dvd_cert | Init.Data.Int.Linear | Int.Linear.Poly → Int.Linear.Poly → ℤ → ℤ → Bool | true |
Std.TreeMap.Raw.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α Unit cmp} [Std.TransCmp cmp],
t.WF → ∀ {l : List α} {k fallback : α}, k ∈ t → (t.insertManyIfNewUnit l).getKeyD k fallback = t.getKeyD k fallback | true |
Orientation.rotation_neg_orientation_eq_neg | 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)) (θ : Real.Angle), (-o).rotation θ = o.rotation (-θ) | true |
_private.Lean.Meta.Tactic.AC.Main.0.Lean.Meta.AC.abstractAtoms.match_1.splitter | Lean.Meta.Tactic.AC.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → (Unit → motive none) → ((inst : Lean.Expr) → motive (some inst)) → motive __do_lift | true |
TopCat.Presheaf.germ | Mathlib.Topology.Sheaves.Stalks | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasColimits C] →
{X : TopCat} →
(F : TopCat.Presheaf C X) →
(U : TopologicalSpace.Opens ↑X) → (x : ↑X) → x ∈ U → (F.obj (Opposite.op U) ⟶ F.stalk x) | true |
Valuation.RankOne.ofRankLeOneStruct._proof_3 | Mathlib.RingTheory.Valuation.RankOne | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] [ValuativeRel.IsNontrivial R],
(ValuativeRel.valuation R).IsNontrivial | false |
_private.Mathlib.Algebra.Order.ToIntervalMod.0.QuotientAddGroup.circularPreorder._simp_6 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} [hp' : Fact (0 < p)] {x₁ x₂ x₃ : α}, btw ↑x₁ ↑x₂ ↑x₃ = (toIcoMod ⋯ x₁ x₂ ≤ toIocMod ⋯ x₁ x₃) | false |
Int.sub_le_sub_left_iff | Init.Data.Int.Order | ∀ {a b c : ℤ}, c - a ≤ c - b ↔ b ≤ a | true |
CompositionAsSet.toComposition_length | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.toComposition.length = c.length | true |
_private.Mathlib.RingTheory.DedekindDomain.Factorization.0.IsDedekindDomain.exists_add_spanSingleton_mul_eq._simp_1_7 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [Nontrivial M₀] (x : ↥(nonZeroDivisors M₀)), (↑x = 0) = False | false |
Std.DHashMap.Internal.Raw₀.Const.insertListₘ._sunfold | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : Type v} →
[BEq α] →
[Hashable α] → (Std.DHashMap.Internal.Raw₀ α fun x => β) → List (α × β) → Std.DHashMap.Internal.Raw₀ α fun x => β | false |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution'.hcdvd | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3}
(self : FermatLastTheoremForThreeGen.Solution'✝ hζ), hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution'.c✝ self | true |
DivisibleHull.nsmul_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] (a : ℕ) (m : M) (s : ℕ+),
a • DivisibleHull.mk m s = DivisibleHull.mk (a • m) s | true |
CategoryTheory.PreservesFiniteLimitsOfFlat.uniq | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type v₁} [inst_2 : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
(F : CategoryTheory.Functor C D) [CategoryTheory.RepresentablyFlat F] {K : CategoryTheory.Functor J C}
{c :... | true |
CategoryTheory.Limits.Cocone.whisker_ι | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C}
(E : CategoryTheory.Functor K J) (c : CategoryTheory.Limits.Cocone F),
(CategoryTheory.Limits.Cocone.... | true |
Lean.Syntax.decodeStrLitAux._unsafe_rec | Init.Meta.Defs | String → String.Pos.Raw → String → Option String | false |
ProbabilityTheory.IsRatCondKernelCDFAux.isRatCondKernelCDF | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β} {f : α × β → ℚ → ℝ},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel ν],
Pr... | true |
LocallyConstant.piecewise._proof_3 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {C₁ C₂ : Set X}, ∀ x ∈ C₁ ∩ C₂, x ∈ C₂ | false |
_private.Aesop.BuiltinRules.0.Aesop.BuiltinRules.pEmpty_false.match_1_1 | Aesop.BuiltinRules | ∀ (motive : PEmpty.{u_1} → Prop) (h : PEmpty.{u_1}), motive h | false |
instCompleteLinearOrderENat._proof_6 | Mathlib.Data.ENat.Lattice | ∀ (s : Set ℕ∞), IsGLB s (sInf s) | false |
Std.Time.Millisecond.instLawfulEqOrdOffset | Std.Time.Time.Unit.Millisecond | Std.LawfulEqOrd Std.Time.Millisecond.Offset | true |
Lean.LocalDecl.replaceFVarId | Lean.LocalContext | Lean.FVarId → Lean.Expr → Lean.LocalDecl → Lean.LocalDecl | true |
MeasureTheory.JordanDecomposition.instSMul._proof_4 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | IsScalarTower ENNReal ENNReal ENNReal | false |
SaturatedAddSubmonoid._sizeOf_1 | Mathlib.Algebra.Group.Submonoid.Saturation | {M : Type u_1} → {inst : AddZeroClass M} → [SizeOf M] → SaturatedAddSubmonoid M → ℕ | false |
FirstOrder.Language.Term.restrictVar | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → [inst : DecidableEq α] → (t : L.Term α) → (↥t.varFinset → β) → L.Term β | true |
ENNReal.nnreal_smul_lt_top_iff | Mathlib.Data.ENNReal.Action | ∀ {x : NNReal} {y : ENNReal}, x ≠ 0 → (x • y < ⊤ ↔ y < ⊤) | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getFolder | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Name → Lean.CoreM Lean.Compiler.LCNF.Simp.ConstantFold.Folder | true |
SmoothBumpCovering.mk.inj | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {ι : Type uι} {E : Type uE} {inst : NormedAddCommGroup E} {inst_1 : NormedSpace ℝ E} {H : Type uH}
{inst_2 : TopologicalSpace H} {I : ModelWithCorners ℝ E H} {M : Type uM} {inst_3 : TopologicalSpace M}
{inst_4 : ChartedSpace H M} {inst_5 : FiniteDimensional ℝ E} {s : Set M} {c : ι → M}
{toFun : (i : ι) → Smooth... | true |
CategoryTheory.ObjectProperty.fullSubcategoryCongr_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P P' : CategoryTheory.ObjectProperty C} (h : P = P'),
(CategoryTheory.ObjectProperty.fullSubcategoryCongr h).functor = CategoryTheory.ObjectProperty.ιOfLE ⋯ | true |
Filter.comap_embedding_atBot | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : Preorder γ] {e : β → γ},
(∀ (b₁ b₂ : β), e b₂ ≤ e b₁ ↔ b₂ ≤ b₁) → (∀ (c : γ), ∃ b, e b ≤ c) → Filter.comap e Filter.atBot = Filter.atBot | true |
Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.ConfigOptions.583794373._hygCtx._hyg.4 | Lean.Compiler.LCNF.ConfigOptions | IO (Lean.Option Bool) | false |
LieSubmodule.instAddCommMonoid._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : LieSubmodule R L M), nsmulRec 0 x = 0 | false |
LocalizedModule.liftOn._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_1} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {α : Type u_3} (f : M × ↥S → α),
(∀ (p p' : M × ↥S), p ≈ p' → f p = f p') → ∀ (a b : M × ↥S), a ≈ b → f a = f b | false |
SemiNormedGrp.Hom.mk.injEq | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (hom' hom'_1 : NormedAddGroupHom M.carrier N.carrier),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | true |
CategoryTheory.GrothendieckTopology.Cover.preOneHypercover_p₂ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
(S : J.Cover X) (x x_1 : S.Arrow) (r : x.Relation x_1), S.preOneHypercover.p₂ r = r.g₂ | true |
Std.ExtHashMap.getD_diff_of_mem_right | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∈ m₂ → (m₁ \ m₂).getD k fallback = fallback | true |
OrderAddMonoidHom.coe_comp_orderHom | 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 γ] (f : β →+o γ) (g : α →+o β),
↑(f.comp g) = (↑f).comp ↑g | true |
CategoryTheory.CostructuredArrow.homMk'_id._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
(f : CategoryTheory.CostructuredArrow S T),
CategoryTheory.CostructuredArrow.mk
(CategoryTheory.CategoryStruct.comp (S.map (CategoryTheory.Ca... | false |
Set.pairwise_iUnion₂_iff | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ((⋃ a ∈ s, a).Pairwise r ↔ ∀ a ∈ s, a.Pairwise r) | true |
_private.Lean.Server.AsyncList.0.IO.AsyncList.getFinishedPrefix.match_5 | Lean.Server.AsyncList | {ε α : Type} →
(motive : IO.AsyncList ε α → Sort u_1) →
(x : IO.AsyncList ε α) →
((hd : α) → (tl : IO.AsyncList ε α) → motive (IO.AsyncList.cons hd tl)) →
(Unit → motive IO.AsyncList.nil) →
((tl : Lean.Server.ServerTask (Except ε (IO.AsyncList ε α))) → motive (IO.AsyncList.delayed tl)) → m... | false |
Lean.Meta.forallMetaTelescopeReducingUntilDefEq | Mathlib.Lean.Meta.Basic | Lean.Expr →
Lean.Expr →
optParam Lean.MetavarKind Lean.MetavarKind.natural →
Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) | true |
CategoryTheory.CommSq.mk._flat_ctor | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z},
autoParam (CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i)
CategoryTheory.CommSq.w._autoParam →
CategoryTheory.CommSq f g h i | false |
surjective_of_isLocalized_span | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (s : Set R),
Ideal.span s = ⊤ →
∀ (Mₚ : ↑s → Type u_5) [inst_5 : (r : ↑s) → AddCommMonoid (Mₚ r)] [inst_6 : (r : ↑s) → Module R (Mₚ r)]
(... | true |
_private.Mathlib.SetTheory.Cardinal.CountableCover.0.Cardinal.mk_subtype_le_of_countable_eventually_mem._simp_1_1 | Mathlib.SetTheory.Cardinal.CountableCover | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
CategoryTheory.IsCardinalFiltered.coeq_condition | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [hκ : Fact κ.IsRegular]
[inst_1 : CategoryTheory.IsCardinalFiltered J κ] {K : Type v'} {j j' : J} (f : K → (j ⟶ j')) (hK : HasCardinalLT K κ)
(k : K),
CategoryTheory.CategoryStruct.comp (f k) (CategoryTheory.IsCardinalFiltered.coeqHom f h... | true |
List.TProd.elim._proof_1 | Mathlib.Data.Prod.TProd | ∀ {ι : Type u_1} (i : ι) (is : List ι), ∀ j ∈ i :: is, ¬j = i → j ∈ is | false |
BooleanSubalgebra.instTopCoe | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → {L : BooleanSubalgebra α} → Top ↥L | true |
MeasureTheory.Measure.tprod | Mathlib.MeasureTheory.Constructions.Pi | {δ : Type u_4} →
{X : δ → Type u_5} →
[inst : (i : δ) → MeasurableSpace (X i)] →
(l : List δ) → ((i : δ) → MeasureTheory.Measure (X i)) → MeasureTheory.Measure (List.TProd X l) | true |
Polynomial.Chebyshev.C_add_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℤ),
Polynomial.Chebyshev.C R (n + 2) = Polynomial.X * Polynomial.Chebyshev.C R (n + 1) - Polynomial.Chebyshev.C R n | true |
Lean.Import._sizeOf_1 | Lean.Setup | Lean.Import → ℕ | false |
CommGrpCat.id_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (X : CommGrpCat) (x : ↑X), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x | true |
HasProd.mul_isCompl | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α} {a b : α}
[ContinuousMul α] {s t : Set β},
IsCompl s t → HasProd (f ∘ Subtype.val) a → HasProd (f ∘ Subtype.val) b → HasProd f (a * b) | true |
Interval.«_aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_term[[_,_]]_1» | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | false |
MonomialOrder.degree_smul_of_mem_nonZeroDivisors | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {r : R},
r ∈ nonZeroDivisors R → ∀ {f : MvPolynomial σ R}, m.degree (r • f) = m.degree f | true |
RatFunc.laurent_laurent | Mathlib.FieldTheory.Laurent | ∀ {R : Type u} [inst : CommRing R] (r s : R) (f : RatFunc R) [inst_1 : IsDomain R],
(RatFunc.laurent r) ((RatFunc.laurent s) f) = (RatFunc.laurent (r + s)) f | true |
MeasurableEquiv.mulLeft.congr_simp | Mathlib.MeasureTheory.Group.LIntegral | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g g_1 : G),
g = g_1 → MeasurableEquiv.mulLeft g = MeasurableEquiv.mulLeft g_1 | true |
Filter.lift_lift_same_le_lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Set α → Set α → Filter β},
(f.lift fun s => f.lift (g s)) ≤ f.lift fun s => g s s | true |
BooleanSubalgebra.copy | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → (L : BooleanSubalgebra α) → (s : Set α) → s = ↑L → BooleanSubalgebra α | true |
FirstOrder.Language.partialOrderTheory.eq_1 | Mathlib.ModelTheory.Order | ∀ (L : FirstOrder.Language) [inst : L.IsOrdered],
L.partialOrderTheory = insert FirstOrder.Language.leSymb.antisymmetric L.preorderTheory | true |
_private.Mathlib.Order.Category.DistLat.0.DistLat.Hom.mk.inj | Mathlib.Order.Category.DistLat | ∀ {X Y : DistLat} {hom' hom'_1 : LatticeHom ↑X ↑Y}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | true |
CompactlySupportedContinuousMap.coeFnMonoidHom._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddMonoid β]
[inst_3 : ContinuousAdd β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g | false |
IsIntegralClosure.equiv.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (A' : Type u_4)
[inst_6 : CommRing A'] [inst_7 : Algebra A' B] [inst_8 : IsIntegralClosure A' R B] [inst_9 : Algebra R A]
... | true |
Std.ExtDTreeMap.instDecidableMem | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → [inst : Std.TransCmp cmp] → {m : Std.ExtDTreeMap α β cmp} → {a : α} → Decidable (a ∈ m) | true |
Std.DHashMap.Raw | Std.Data.DHashMap.RawDef | (α : Type u) → (α → Type v) → Type (max u v) | true |
Ideal.quotientEquiv._proof_6 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : Ring R] {S : Type u_2} [inst_1 : Ring S], RingHomClass (S →+* R) S R | false |
CategoryTheory.GlueData'.t''._proof_14 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (D : CategoryTheory.GlueData' C) (i : D.J), D.U i = D.U i | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_smul._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.