name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
lipschitzOnWith_iff_norm_inv_mul_le | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F] {s : Set E} {f : E → F}
{C : NNReal}, LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖(f x)⁻¹ * f y‖ ≤ ↑C * ‖x⁻¹ * y‖ | true |
BitVec.umulOverflow.eq_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.umulOverflow y = decide (x.toNat * y.toNat ≥ 2 ^ w) | true |
_private.Mathlib.Data.List.Nodup.0.List.nodup_iff_count_eq_one._proof_1_4 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} [inst : BEq α] (x : α),
(List.count x l ≤ 1) = ¬(1 ≤ List.count x l → List.count x l = 1) →
List.count x l ≤ 1 → 0 < (List.filter (fun x_1 => x_1 == x) l).length | false |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ofIterate._simp_3 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
InnerProductGeometry.norm_add_eq_norm_sub_iff_angle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
‖x + y‖ = ‖x - y‖ ↔ InnerProductGeometry.angle x y = Real.pi / 2 | true |
CategoryTheory.ShortComplex.leftHomologyIso_hom_naturality_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ : S₁ ⟶ S₂) {Z : C}
(h : S₂.homology ⟶ Z),
CategoryTheory.CategoryStruct.comp S₁.leftHomologyIso.hom
(Cat... | true |
Lean.Meta.FindSplitImpl.Context.mk | Lean.Meta.Tactic.SplitIf | Lean.ExprSet → Lean.Meta.SplitKind → Lean.Meta.FindSplitImpl.Context | true |
Multiset.card_eq_countP_add_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
s.card = Multiset.countP p s + Multiset.countP (fun x => ¬p x) s | true |
Nat.and_left_comm | Batteries.Data.Nat.Bitwise | ∀ (x y z : ℕ), x &&& (y &&& z) = y &&& (x &&& z) | true |
Substring.Raw.Valid.next_stop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → s.next { byteIdx := s.bsize } = { byteIdx := s.bsize } | true |
_private.Init.Meta.0.Lean.Parser.Tactic._aux_Init_Meta___macroRules_Lean_Parser_Tactic_declareSimpLikeTactic_1.match_4 | Init.Meta | (motive : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command → Sort u_1) →
(__discr : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command) →
((kind tkn : Lean.TSyntax `term) → (stx : Lean.TSyntax `command) → motive (kind, tkn, stx)) → motive __discr | false |
WithBot.insertBot | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithBot α) | true |
Finset.preimage_subset | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} {f : α ↪ β} {s : Finset β} {t : Finset α}, s ⊆ Finset.map f t → s.preimage ⇑f ⋯ ⊆ t | true |
Lean.IR.ToIR.BuilderState.mk.inj | Lean.Compiler.IR.ToIR | ∀ {vars : Std.HashMap Lean.FVarId Lean.IR.Arg} {joinPoints : Std.HashMap Lean.FVarId Lean.IR.JoinPointId} {nextId : ℕ}
{vars_1 : Std.HashMap Lean.FVarId Lean.IR.Arg} {joinPoints_1 : Std.HashMap Lean.FVarId Lean.IR.JoinPointId}
{nextId_1 : ℕ},
{ vars := vars, joinPoints := joinPoints, nextId := nextId } =
{ ... | true |
Algebra.semiringToRing._proof_1 | Mathlib.Algebra.Algebra.Basic | ∀ {A : Type u_1} (R : Type u_2) [inst : CommRing R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (z : ℕ),
(algebraMap R A) ↑↑z = ↑z | false |
BoundedContinuousFunction.natCast_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Type u_2} [inst_1 : PseudoMetricSpace β] [inst_2 : NatCast β] (n : ℕ)
(x : α), ↑n x = ↑n | true |
CategoryTheory.Functor.IsStronglyCocartesian.map_isHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [inst_2 : p.IsStronglyCocartesian f φ]
{S' : 𝒮} {b' : 𝒳} {g : S ⟶ S'} {f' : R ⟶ S'} (hf' : f' = CategoryTheor... | true |
RingCat.limitRing._proof_45 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J RingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | false |
Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty.elim | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Finset «$α»)} →
{motive : Mathlib.Meta.Finset.ProveEmptyOrConsResult s → Sort u} →
(t : Mathlib.Meta.Finset.ProveEmptyOrConsResult s) →
t.ctorIdx = 0 → ((pf : Q(«$s» = ∅)) → motive (Mathlib.Meta.Finset.ProveEmptyOrConsResult.empty pf)) → motive t | false |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.Basic.0.ExteriorAlgebra.map_injective.match_1_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_3} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f : M →ₗ[R] N} (motive : (∃ g, g ∘ₗ f = LinearMap.id) → Prop)
(hf : ∃ g, g ∘ₗ f = LinearMap.id), (∀ (w : N →ₗ[R] M) (hgf : w ∘ₗ f = LinearMap.id), motiv... | false |
_private.Lean.Meta.Coe.0.Lean.Meta.coerceSimple?.match_1 | Lean.Meta.Coe | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((result : Lean.Expr) → (snd : List Lean.Name) → motive (Lean.LOption.some (result, snd))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef) → motive __do_lift | false |
AddActionSemiHomClass.mk | Mathlib.GroupTheory.GroupAction.Hom | ∀ {F : Type u_8} {M : outParam (Type u_9)} {N : outParam (Type u_10)} {φ : outParam (M → N)} {X : outParam (Type u_11)}
{Y : outParam (Type u_12)} [inst : VAdd M X] [inst_1 : VAdd N Y] [inst_2 : FunLike F X Y],
(∀ (f : F) (c : M) (x : X), f (c +ᵥ x) = φ c +ᵥ f x) → AddActionSemiHomClass F φ X Y | true |
Filter.smul.instNeBot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {f : Filter α} {g : Filter β} [f.NeBot] [g.NeBot], (f • g).NeBot | true |
instMonoidalCategorySFinKer._proof_22 | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X : SFinKer),
(Measurable fun x => (PUnit.unit, x)) →
Measurable Prod.snd →
CategoryTheory.CategoryStruct.comp { hom := ProbabilityTheory.Kernel.id.map Prod.snd, property := ⋯ }
{ hom := ProbabilityTheory.Kernel.id.map fun x => (PUnit.unit, x), property := ⋯ } =
CategoryTheory.CategoryS... | false |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_3 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), Module.Finite ℝ (WithLp 2 (Fin d → ℝ)) | false |
Asymptotics.SuperpolynomialDecay.add | Mathlib.Analysis.Asymptotics.SuperpolynomialDecay | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {k f g : α → β} [inst : TopologicalSpace β] [inst_1 : CommSemiring β]
[ContinuousAdd β],
Asymptotics.SuperpolynomialDecay l k f →
Asymptotics.SuperpolynomialDecay l k g → Asymptotics.SuperpolynomialDecay l k (f + g) | true |
Subgroup.quotientiInfSubgroupOfEmbedding._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (i : ι), iInf f ≤ f i | false |
EMetric.ball_disjoint | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α} {ε₁ ε₂ : ENNReal},
ε₁ + ε₂ ≤ edist x y → Disjoint (Metric.eball x ε₁) (Metric.eball y ε₂) | true |
_private.Init.Data.Order.Lemmas.0.Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax._simp_1 | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : Max α] [inst_1 : LE α] [Std.LawfulOrderSup α] {a b c : α}, (a ⊔ b ≤ c) = (a ≤ c ∧ b ≤ c) | false |
le_mul_of_one_le_left' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : LE α] [MulRightMono α] {a b : α}, 1 ≤ b → a ≤ b * a | true |
Std.LawfulEqOrd.compare_eq_iff_eq._simp_1 | Init.Data.Order.Ord | ∀ {α : Type u} [inst : Ord α] [Std.LawfulEqOrd α] {a b : α}, (compare a b = Ordering.eq) = (a = b) | false |
Std.HashSet.Raw.WF.casesOn | Std.Data.HashSet.Raw | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{m : Std.HashSet.Raw α} → {motive : m.WF → Sort u_1} → (t : m.WF) → ((out : m.inner.WF) → motive ⋯) → motive t | false |
_private.Mathlib.Tactic.Simproc.ExistsAndEq.0.ExistsAndEq.withNestedExistsElim.match_1 | Mathlib.Tactic.Simproc.ExistsAndEq | (motive : List ExistsAndEq.VarQ → Sort u_1) →
(exs : List ExistsAndEq.VarQ) →
(Unit → motive []) →
((u : Lean.Level) → (β : Q(Sort u)) → (b : Q(«$β»)) → (tl : List ExistsAndEq.VarQ) → motive (⟨u, ⟨β, b⟩⟩ :: tl)) →
motive exs | false |
Configuration.HasPoints.lineCount_eq_pointCount | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} [inst : Membership P L] [Configuration.HasPoints P L] [inst_2 : Fintype P]
[inst_3 : Fintype L],
Fintype.card P = Fintype.card L →
∀ {p : P} {l : L}, p ∉ l → Configuration.lineCount L p = Configuration.pointCount P l | true |
Set.FiniteExhaustion._sizeOf_inst | Mathlib.Data.Set.FiniteExhaustion | {α : Type u_1} → (s : Set α) → [SizeOf α] → [(a : α) → SizeOf (s a)] → SizeOf s.FiniteExhaustion | false |
IntermediateField.induction_on_adjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] [FiniteDimensional F E]
(P : IntermediateField F E → Prop),
P ⊥ →
(∀ (K : IntermediateField F E) (x : E), P K → P (IntermediateField.restrictScalars F (↥K)⟮x⟯)) →
∀ (K : IntermediateField F E), P K | true |
Lean.Sym.UInt16.lt_eq_true | Init.Sym.Lemmas | ∀ (a b : UInt16), decide (a < b) = true → (a < b) = True | true |
Std.HashMap.Raw.getKey_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α} (h' : k ∈ m), m.getKey k h' = k | true |
AlgebraicGeometry.Scheme.basicOpen_restrict | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {V U : X.Opens} (i : V ⟶ U) (f : ↑(X.presheaf.obj (Opposite.op U))),
X.basicOpen (TopCat.Presheaf.restrict f i) ≤ X.basicOpen f | true |
CategoryTheory.Pretriangulated.instHasFiniteCoproducts | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.Limits.H... | true |
Std.DTreeMap.Const.getKey?_insertMany_list_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Const.insertMany t l).getKey? k' = some k | true |
ProbabilityTheory.complexMGF_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (z : ℂ),
ProbabilityTheory.complexMGF id (ProbabilityTheory.gaussianReal μ v) z = Complex.exp (z * ↑μ + ↑↑v * z ^ 2 / 2) | true |
intervalIntegral.measure_integral_sub_linear_isLittleO_of_tendsto_ae_of_le | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {ι : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a : ℝ} {c : E}
{l l' : Filter ℝ} {lt : Filter ι} {μ : MeasureTheory.Measure ℝ} {u v : ι → ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ]
[CompleteSpace E] [intervalIntegral.FTCFilter a l l'],
StronglyMeasurableAtFil... | true |
Matroid.freeOn.eq_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (E : Set α), Matroid.freeOn E = (Matroid.loopyOn E)✶ | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems.isErased | Lean.Elab.Tactic.Do.Attr | Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems → Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Bool | true |
Ring.instAddCommMonoidDirectLimit._aux_1 | Mathlib.Algebra.Colimit.Ring | {ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → CommRing (G i)] →
(f : (i j : ι) → i ≤ j → G i → G j) → Ring.DirectLimit G f → Ring.DirectLimit G f → Ring.DirectLimit G f | false |
PSigma.Lex.preorder._proof_4 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : Preorder ι] [inst_1 : (i : ι) → Preorder (α i)] (a b : Σₗ' (i : ι), α i),
a < b ↔ a ≤ b ∧ ¬b ≤ a | false |
«command#long_names_» | Mathlib.Util.LongNames | Lean.ParserDescr | true |
OrderedFinpartition.eraseMiddle._proof_11 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (hc : Set.range (c.emb 0) ≠ {0}) (i j : Fin c.length),
i < j →
(fun m =>
if h : m = c.index 0 then
(c.emb m
(Fin.cast ⋯ ⟨Function.update c.partSize (c.index 0) (c.partSize (c.index 0) - 1) m - 1, ⋯⟩.succ)).pred
⋯
... | false |
Sub.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Sub α} → {α' : Type u} → {t' : Sub α'} → α = α' → t ≍ t' → Sub.noConfusionType P t t' | false |
BooleanAlgebra.recOn | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} →
{motive : BooleanAlgebra α → Sort u_1} →
(t : BooleanAlgebra α) →
([toDistribLattice : DistribLattice α] →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
[toTop : Top α] →
[toBot : Bot α] →
... | false |
RingHom.liftOfRightInverse_comp | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (g : { g // RingHom.ker f ≤ RingHom.ker g }),
((f.liftOfRightInverse f_inv hf) g).comp f = ↑g | true |
LinearMap.extendScalarsOfIsLocalizationEquiv._proof_8 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
{N : Type u_2} [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] [IsScalarTower R A M]
[inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : Module A N] [IsScalarTower R ... | false |
Int.Linear.Poly.insert | Init.Data.Int.Linear | ℤ → Int.Linear.Var → Int.Linear.Poly → Int.Linear.Poly | true |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae.match_1_1 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {α : Type} [inst : Finite α] {B : CompHaus} (X : α → CompHaus) (π : (a : α) → X a ⟶ B)
(motive : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π) → Prop)
(x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)),
(∀ (x : CategoryTheory.Epi (CategoryTheory.Limits.Sigma.desc π)), motive x) → motive x | false |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_2 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (M : Matroid α), M.3 ∅ = True | false |
CategoryTheory.shrinkYonedaMonObjObjEquiv._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.ShrinkYoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] {M : CategoryTheory.Mon C} {Y : Cᵒᵖ},
Small.{u_1, u_2} ↑((CategoryTheory.yonedaMon.obj M).obj Y) | false |
_private.Mathlib.AlgebraicTopology.DoldKan.Degeneracies.0.AlgebraicTopology.DoldKan.σ_comp_P_eq_zero._simp_1_5 | Mathlib.AlgebraicTopology.DoldKan.Degeneracies | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
Tactic.NormNum.int_lcm_helper | Mathlib.Tactic.NormNum.GCD | ∀ {x y : ℤ} {x' y' d : ℕ}, x.natAbs = x' → y.natAbs = y' → x'.lcm y' = d → x.lcm y = d | true |
IsZGroup.isCyclic_commutator | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ (G : Type u_1) [inst : Group G] [Finite G] [IsZGroup G], IsCyclic ↥(commutator G) | true |
CategoryTheory.Limits.limit.isLimit | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.cone F) | true |
LinearMap.compMultilinearMap_add | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃]
[inst_4 : (i : ι) → Module R (M₁ i)] [inst_5 : Module R M₂] [inst_6 : Module R M₃] (g : M₂ →ₗ[R] M₃)
(f₁ f₂ : Multili... | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.instNoMinOrderElemIio.match_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (a_1 : ↑(Set.Iio a)) (motive : (∃ b, b < ↑a_1) → Prop) (x : ∃ b, b < ↑a_1),
(∀ (b : α) (hb : b < ↑a_1), motive ⋯) → motive x | false |
BitVec.ushiftRight_and_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x &&& y) >>> n = x >>> n &&& y >>> n | true |
ENNReal.toReal_eq_toReal_iff' | Mathlib.Data.ENNReal.Basic | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ ⊤ → (x.toReal = y.toReal ↔ x = y) | true |
List.zipWithM.loop | Init.Data.List.Control | {m : Type u → Type v} →
[Monad m] → {α : Type w} → {β : Type x} → {γ : Type u} → (α → β → m γ) → List α → List β → Array γ → m (List γ) | true |
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegrable_sub_inv_iff._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | false |
GradedRing.projZeroRingHom'_surjective | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [inst_4 : CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜], Function.Surjective ⇑(GradedRing.projZero... | true |
factorPowSucc.isUnit_of_isUnit_image | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_3} [inst : CommRing R] {I : Ideal R} {n : ℕ},
n > 0 → ∀ {a : R ⧸ I ^ (n + 1)}, IsUnit ((Ideal.Quotient.factorPow I ⋯) a) → IsUnit a | true |
Filter.tendstoIxxClass_principal | Mathlib.Order.Filter.Interval | ∀ {α : Type u_1} {s t : Set α} {Ixx : α → α → Set α},
Filter.TendstoIxxClass Ixx (Filter.principal s) (Filter.principal t) ↔ ∀ x ∈ s, ∀ y ∈ s, Ixx x y ⊆ t | true |
optParam | Init.Prelude | (α : Sort u) → α → Sort u | true |
Std.Slice.Internal.SubarrayData.stop_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u} (self : Std.Slice.Internal.SubarrayData α), self.stop ≤ self.array.size | true |
CategoryTheory.GrothendieckTopology.W_eq_inverseImage_isomorphisms | Mathlib.CategoryTheory.Sites.Localization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_2) [inst_1 : CategoryTheory.Category.{v_2, u_2} A] [inst_2 : CategoryTheory.HasWeakSheafify J A],
J.W =
(CategoryTheory.MorphismProperty.isomorphisms (CategoryTheory.Sheaf J A)).inverseImage
... | true |
OrthogonalIdempotents.mul_sum_of_mem | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} {e : I → R},
OrthogonalIdempotents e → ∀ {i : I} {s : Finset I}, i ∈ s → e i * ∑ j ∈ s, e j = e i | true |
CategoryTheory.Enriched.HasConicalLimitsOfSize.hasConicalLimitsOfShape._autoParam | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | Lean.Syntax | false |
Mathlib.Tactic.BicategoryLike.NormalExpr.nodesAux | Mathlib.Tactic.Widget.StringDiagram | {ρ : Type} →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ (Mathlib.Tactic.BicategoryLike.CoherenceM ρ)] →
ℕ →
Mathlib.Tactic.BicategoryLike.NormalExpr →
Mathlib.Tactic.BicategoryLike.CoherenceM ρ (List (List Mathlib.Tactic.Widget.StringDiagram.Node)) | true |
Mathlib.Tactic.GCongr.GCongrKey.recOn | Mathlib.Tactic.GCongr.Core | {motive : Mathlib.Tactic.GCongr.GCongrKey → Sort u} →
(t : Mathlib.Tactic.GCongr.GCongrKey) →
((relName head : Lean.Name) → (arity : ℕ) → motive { relName := relName, head := head, arity := arity }) → motive t | false |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getNumParams | Lean.Meta.RecursorInfo | Array Lean.Expr → Lean.Expr → ℕ → ℕ | true |
CategoryTheory.Arrow.equivSigma | Mathlib.CategoryTheory.Comma.Arrow | (T : Type u) → [inst : CategoryTheory.Category.{v, u} T] → CategoryTheory.Arrow T ≃ (X : T) × (Y : T) × (X ⟶ Y) | true |
AlgebraNorm.mk.inj | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} {inst : SeminormedCommRing R} {S : Type u_2} {inst_1 : Ring S} {inst_2 : Algebra R S}
{toRingNorm : RingNorm S} {smul' : ∀ (a : R) (x : S), toRingNorm.toFun (a • x) = ‖a‖ * toRingNorm.toFun x}
{toRingNorm_1 : RingNorm S} {smul'_1 : ∀ (a : R) (x : S), toRingNorm_1.toFun (a • x) = ‖a‖ * toRingNorm_1.... | true |
ContinuousAlternatingMap.curryLeft_add | Mathlib.Analysis.Normed.Module.Alternating.Curry | ∀ {𝕜 : 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 : ℕ}
(f g : E [⋀^Fin (n + 1)]→L[𝕜] F), (f + g).curryLeft = f.curryLeft + g.curryLeft | true |
cantorToTernary | Mathlib.Topology.Instances.CantorSet | ℝ → Stream' (Fin 3) | true |
Vector.extract_eq_pop | Init.Data.Vector.Extract | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {stop : ℕ} (h : stop = n - 1), xs.extract 0 stop = Vector.cast ⋯ xs.pop | true |
TensorPower.gmonoid._proof_2 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (n : ℕ)
(a : GradedMonoid fun i => TensorPower R i M),
GradedMonoid.mk (n.succ • a.fst) (GradedMonoid.GMonoid.gnpowRec n.succ a.snd) =
⟨n • a.fst, GradedMonoid.GMonoid.gnpowRec n a.snd⟩ * a | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.mergeFailures.match_1 | Lean.Elab.App | (motive : Lean.Elab.Term.TermElabResult Lean.Expr → Sort u_1) →
(x : Lean.Elab.Term.TermElabResult Lean.Expr) →
((ex : Lean.Exception) → (a : Lean.Elab.Term.SavedState) → motive (EStateM.Result.error ex a)) →
((x : Lean.Elab.Term.TermElabResult Lean.Expr) → motive x) → motive x | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr.h | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof | true |
TensorProduct.tmul_neg | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {P : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup P] [inst_3 : Module R M] [inst_4 : Module R P] (m : M) (p : P), m ⊗ₜ[R] (-p) = -m ⊗ₜ[R] p | true |
Stream'.WSeq.seq_destruct_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α), Stream'.Seq.destruct s.think = some (none, s) | true |
Polynomial.trinomial | Mathlib.Algebra.Polynomial.UnitTrinomial | {R : Type u_1} → [inst : Semiring R] → ℕ → ℕ → ℕ → R → R → R → Polynomial R | true |
MeasureTheory.setLAverage_congr_fun | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f g : α → ENNReal},
MeasurableSet s → Set.EqOn f g s → ⨍⁻ (x : α) in s, f x ∂μ = ⨍⁻ (x : α) in s, g x ∂μ | true |
TopCat.instCategory._proof_2 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (f : X.Hom Y), { hom' := { hom' := ContinuousMap.id ↑Y }.hom'.comp f.hom' } = f | false |
List.sym2_eq_nil_iff | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, xs.sym2 = [] ↔ xs = [] | true |
Fix.mk._flat_ctor | Mathlib.Control.Fix | {α : Type u_3} → ((α → α) → α) → Fix α | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.diff.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β),
m₁.diff m₂ =
if (↑m₁).size ≤ (↑m₂).size then Std.DHashMap.Internal.Raw₀.filter (fun k x => !m₂.contains k) m₁
else ↑(m₁.eraseManyEntries ↑m₂) | true |
Primrec.list_head? | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.head? | true |
Std.TreeMap.getElem!_modify_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β] {f : β → β}, (t.modify k f)[k]! = (Option.map f t[k]?).get! | true |
Polynomial.le_trailingDegree_C | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {a : R} [inst : Semiring R], 0 ≤ (Polynomial.C a).trailingDegree | true |
RootPairing.finrank_rootSpan_map_polarization_eq_finrank_corootSpan | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [IsDomain R] [inst_5 : Module R M] [inst_6 : Module R N]
(P : RootPairing ι R M N) [P.IsAnisotropic],
Module.finrank R ↥(Submodule.map P.Polarization (P.rootSp... | true |
Nat.forM | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → m Unit | true |
IsPGroup.of_surjective | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G],
IsPGroup p G → ∀ {H : Type u_2} [inst_1 : Group H] (ϕ : G →* H), Function.Surjective ⇑ϕ → IsPGroup p H | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.