name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Parser.Term.doHave._regBuiltin.Lean.Parser.Term.doHave_1 | Lean.Parser.Do | IO Unit | false |
_private.Mathlib.Analysis.Complex.OpenMapping.0.AnalyticOnNhd.eq_const_of_re_eq_const._proof_1_2 | Mathlib.Analysis.Complex.OpenMapping | ∀ {f : ℂ → ℂ} {U : Set ℂ} {c₀ : ℝ},
AnalyticOnNhd ℂ f U → (∀ x ∈ U, (f x).re = c₀) → IsOpen U → IsConnected U → ∀ z₀ ∈ U, (¬∃ c, ∀ x ∈ U, f x = c) → False | false |
Lean.Doc.Part.below_2 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
List (Lean.Doc.Part i b p) → Sort (max ((max (max u v) w) + 1) u_1) | false |
MeasureTheory.setToFun_mono_left' | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ {α : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {G'' : Type u_8} [inst_2 : NormedAddCommGroup G''] [inst_3 : PartialOrder G'']
[IsOrderedAddMonoid G''] [inst_5 : NormedSpace ℝ G''] [inst_6 : CompleteSpace G''] [OrderClosedTopology G'']
{T T' : Set α → E →L[ℝ] G''} {C C' : ℝ} (hT : MeasureTheory.DominatedFinMeasAdditive μ T C)
(hT' : MeasureTheory.DominatedFinMeasAdditive μ T' C'),
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : E), (T s) x ≤ (T' s) x) →
∀ (f : α → E), MeasureTheory.setToFun μ T hT f ≤ MeasureTheory.setToFun μ T' hT' f | true |
PNat.instSuccAddOrder | Mathlib.Data.PNat.Order | SuccAddOrder ℕ+ | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.weierstrassPExcept_eq_tsum._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
contMDiff_zero_iff | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'},
ContMDiff I I' 0 f ↔ Continuous f | true |
UniformSpaceCat.instFunLike | Mathlib.Topology.Category.UniformSpace | (X : UniformSpaceCat) → (Y : UniformSpaceCat) → FunLike { f // UniformContinuous f } X.carrier Y.carrier | true |
Nat.log_le_clog._simp_1 | Mathlib.Data.Nat.Log | ∀ (b n : ℕ), (Nat.log b n ≤ Nat.clog b n) = True | false |
dvd_differentIdeal_iff | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {B : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[IsDedekindDomain A] [inst_5 : IsDedekindDomain B] [inst_6 : Module.IsTorsionFree A B] [Module.Finite A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)] {P : Ideal B} [inst_9 : P.IsPrime],
P ∣ differentIdeal A B ↔ ¬Algebra.IsUnramifiedAt A P | true |
WType.toList.match_1 | Mathlib.Data.W.Constructions | (γ : Type u_1) →
(motive : WType (WType.Listβ γ) → Sort u_2) →
(x : WType (WType.Listβ γ)) →
((f : WType.Listβ γ WType.Listα.nil → WType (WType.Listβ γ)) → motive (WType.mk WType.Listα.nil f)) →
((hd : γ) →
(f : WType.Listβ γ (WType.Listα.cons hd) → WType (WType.Listβ γ)) →
motive (WType.mk (WType.Listα.cons hd) f)) →
motive x | false |
_private.Aesop.Util.Basic.0.Aesop.filterTrieM.go.match_3 | Aesop.Util.Basic | {α : Type} →
(motive : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
((key : Lean.Meta.DiscrTree.Key) → (t : Lean.Meta.DiscrTree.Trie α) → motive (key, t)) → motive x | false |
Lean.Server.Test.Runner.Client.InfoPopup.ctorIdx | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.InfoPopup → ℕ | false |
Aesop.ElabM.Context.casesOn | Aesop.ElabM | {motive : Aesop.ElabM.Context → Sort u} →
(t : Aesop.ElabM.Context) →
((parsePriorities : Bool) → (goal : Lean.MVarId) → motive { parsePriorities := parsePriorities, goal := goal }) →
motive t | false |
Lean.MessageData.withContext | Lean.Message | Lean.MessageDataContext → Lean.MessageData → Lean.MessageData | true |
CategoryTheory.Mon.hom_one | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M : CategoryTheory.Mon C) [inst_3 : CategoryTheory.IsCommMonObj M.X],
CategoryTheory.MonObj.one.hom = CategoryTheory.MonObj.one | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.mkOfLe.match_1.splitter | Mathlib.AlgebraicTopology.SimplexCategory.Basic | (motive : Fin (1 + 1) → Sort u_1) → (x : Fin (1 + 1)) → (Unit → motive 0) → (Unit → motive 1) → motive x | true |
Std.DHashMap.Internal.Raw₀.getKey?_eq_some_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k k' : α}, m.getKey? k = some k' ↔ ∃ (h : m.contains k = true), m.getKey k h = k' | true |
_private.Lean.AddDecl.0.Lean.addDecl._sparseCasesOn_10 | Lean.AddDecl | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
HomologicalComplex.mapBifunctor.hom_ext_iff | Mathlib.Algebra.Homology.Bifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [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} D] {I₁ : Type u_4}
{I₂ : Type u_5} {J : Type u_6} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : CategoryTheory.Preadditive D] {K₁ : HomologicalComplex C₁ c₁} {K₂ : HomologicalComplex C₂ c₂}
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)} [inst_6 : F.PreservesZeroMorphisms]
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] {c : ComplexShape J} [inst_8 : TotalComplexShape c₁ c₂ c]
[inst_9 : K₁.HasMapBifunctor K₂ F c] [inst_10 : DecidableEq J] {Y : D} {j : J}
{f g : (K₁.mapBifunctor K₂ F c).X j ⟶ Y},
f = g ↔
∀ (i₁ : I₁) (i₂ : I₂) (h : c₁.π c₂ c (i₁, i₂) = j),
CategoryTheory.CategoryStruct.comp (K₁.ιMapBifunctor K₂ F c i₁ i₂ j h) f =
CategoryTheory.CategoryStruct.comp (K₁.ιMapBifunctor K₂ F c i₁ i₂ j h) g | true |
LieRinehartRing.lie_smul_eq_mul' | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {A : Type u_1} {L : Type u_2} {inst : CommRing A} {inst_1 : LieRing L} {inst_2 : Module A L}
{inst_3 : LieRingModule L A} [self : LieRinehartRing A L] (a b : A) (x : L), ⁅a • x, b⁆ = a * ⁅x, b⁆ | true |
StieltjesFunction.measurable_measure | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} {x : MeasurableSpace α} {f : α → StieltjesFunction ℝ},
(∀ (q : ℝ), Measurable fun a => ↑(f a) q) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atBot (nhds 0)) →
(∀ (a : α), Filter.Tendsto (↑(f a)) Filter.atTop (nhds 1)) → Measurable fun a => (f a).measure | true |
OrderMonoidWithZeroHom.toMonoidWithZeroHom_mk | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} {hα : Preorder α} {hα' : MulZeroOneClass α} {hβ : Preorder β} {hβ' : MulZeroOneClass β}
(f : α →*₀ β) (hf : Monotone ⇑f), ↑{ toMonoidWithZeroHom := f, monotone' := hf } = f | true |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.initFn.match_7._@.Batteries.Tactic.Trans.2247956323._hygCtx._hyg.2 | Batteries.Tactic.Trans | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((xs : Array Lean.Expr) → (fst : Array Lean.BinderInfo) → (targetTy : Lean.Expr) → motive (xs, fst, targetTy)) →
motive __discr | false |
_private.Mathlib.MeasureTheory.Group.Integral.0.MeasureTheory.integral_eq_zero_of_mul_right_eq_neg._simp_1_2 | Mathlib.MeasureTheory.Group.Integral | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (f : α → G), -∫ (a : α), f a ∂μ = ∫ (a : α), -f a ∂μ | false |
mem_leftCoset_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Monoid α] (s : Submonoid α) {a : α}, a • ↑s = ↑s → a ∈ s | true |
Real.geom_mean_le_arith_mean4_weighted | Mathlib.Analysis.MeanInequalities | ∀ {w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ},
0 ≤ w₁ →
0 ≤ w₂ →
0 ≤ w₃ →
0 ≤ w₄ →
0 ≤ p₁ →
0 ≤ p₂ →
0 ≤ p₃ →
0 ≤ p₄ →
w₁ + w₂ + w₃ + w₄ = 1 → p₁ ^ w₁ * p₂ ^ w₂ * p₃ ^ w₃ * p₄ ^ w₄ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ + w₄ * p₄ | true |
addSubgroupOfIdempotent._proof_3 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : Finite G] (S : Set G) (hS1 : S.Nonempty) (hS2 : S + S = S),
0 ∈ (addSubmonoidOfIdempotent S hS1 hS2).carrier | false |
groupCohomology.instEpiModuleCatH2π | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
CategoryTheory.Epi (groupCohomology.H2π A) | true |
CategoryTheory.StrictlyUnitaryPseudofunctorCore.map₂_whisker_right._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | Lean.Syntax | false |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{x : Lean.Grind.AC.Var} →
{c₁ : Lean.Meta.Grind.AC.EqCnstr} →
{x' : Lean.Grind.AC.Var} →
{c₁' : Lean.Meta.Grind.AC.EqCnstr} →
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x' c₁' →
(x = x' → c₁ = c₁' → P) → P | false |
CategoryTheory.Limits.CoproductDisjoint.isPullback_of_isInitial | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_1} {X : ι → C}
[CategoryTheory.Limits.CoproductDisjoint X] {c : CategoryTheory.Limits.Cofan X}
(hc : CategoryTheory.Limits.IsColimit c) {Y : C} (hY : CategoryTheory.Limits.IsInitial Y) {i j : ι}
[CategoryTheory.Limits.HasPullback (c.inj i) (c.inj j)],
i ≠ j → CategoryTheory.IsPullback (hY.to (X i)) (hY.to (X j)) (c.inj i) (c.inj j) | true |
AlgEquiv.ofInjectiveField._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {E : Type u_1} {F : Type u_2} [inst_1 : DivisionRing E] [inst_2 : Semiring F]
[Nontrivial F] [inst_4 : Algebra R E] [inst_5 : Algebra R F] (f : E →ₐ[R] F), Function.Injective ⇑f.toRingHom | false |
Lean.Meta.Sym.AlphaShareCommon.State.noConfusionType | Lean.Meta.Sym.AlphaShareCommon | Sort u → Lean.Meta.Sym.AlphaShareCommon.State → Lean.Meta.Sym.AlphaShareCommon.State → Sort u | false |
Sum.map_bijective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Bijective (Sum.map f g) ↔ Function.Bijective f ∧ Function.Bijective g | true |
Set.chainHeight_eq_top_iff | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), s.chainHeight r = ⊤ ↔ ∀ (n : ℕ), ∃ t ⊆ s, t.encard = ↑n ∧ IsChain r t | true |
SubAddAction.ofStabilizer.conjMap._proof_5 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {g : G} {a b : α} (hg : b = g +ᵥ a)
(x : ↥(AddAction.stabilizer G a)) (x_1 : ↥(SubAddAction.ofStabilizer G a)),
⟨g +ᵥ ↑(x +ᵥ x_1), ⋯⟩ = (AddAction.stabilizerEquivStabilizer hg) x +ᵥ ⟨g +ᵥ ↑x_1, ⋯⟩ | false |
_private.Init.Data.UInt.Bitwise.0.UInt8.xor_eq_zero_iff._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Lean.Elab.CompletionInfo.option.inj | Lean.Elab.InfoTree.Types | ∀ {stx stx_1 : Lean.Syntax}, Lean.Elab.CompletionInfo.option stx = Lean.Elab.CompletionInfo.option stx_1 → stx = stx_1 | true |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp eK.hom h.i) S.g = 0 | false |
Lean.Expr.name? | Lean.Util.Recognizers | Lean.Expr → Option Lean.Name | true |
CochainComplex.of._proof_3 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{α : Type u_1} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
(d : (n : α) → X n ⟶ X (n + 1)),
(∀ (n : α), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) →
∀ (i j k : α),
(ComplexShape.up α).Rel i j →
(ComplexShape.up α).Rel j k →
CategoryTheory.CategoryStruct.comp
(if h : i + 1 = j then CategoryTheory.CategoryStruct.comp (d i) (CategoryTheory.eqToHom ⋯) else 0)
(if h : j + 1 = k then CategoryTheory.CategoryStruct.comp (d j) (CategoryTheory.eqToHom ⋯) else 0) =
0 | false |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.wittStructureRat_vars._proof_1_5 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {idx : Type u_1} (n k : ℕ) (i : idx), ∀ j < k + 1, k ∈ Finset.range (n + 1) → (i, j).2 < n + 1 | false |
Measurable.coe_real_ereal | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : α → ℝ}, Measurable f → Measurable fun x => ↑(f x) | true |
NFA.evalFrom_append | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (S : Set σ) (x y : List α),
M.evalFrom S (x ++ y) = M.evalFrom (M.evalFrom S x) y | true |
Monoid.Coprod.fst | Mathlib.GroupTheory.Coprod.Basic | {M : Type u_1} → {N : Type u_2} → [inst : Monoid M] → [inst_1 : Monoid N] → Monoid.Coprod M N →* M | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.ContDiffWithinAt.congr_of_eventuallyEq.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} (motive : (n : WithTop ℕ∞) → ContDiffWithinAt 𝕜 n f s x → Prop) (n : WithTop ℕ∞)
(h : ContDiffWithinAt 𝕜 n f s x),
(∀ (h : ContDiffWithinAt 𝕜 ⊤ f s x), motive none h) →
(∀ (n : ℕ∞) (h : ContDiffWithinAt 𝕜 (↑n) f s x), motive (some n) h) → motive n h | false |
ProfiniteGrp.coe_comp | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y Z : ProfiniteGrp.{u_1}} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(ProfiniteGrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(ProfiniteGrp.Hom.hom g) ∘ ⇑(ProfiniteGrp.Hom.hom f) | true |
Option.toArray_pmap | Init.Data.Option.Attach | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {o : Option α} {f : (a : α) → p a → β} (h : ∀ (a : α), o = some a → p a),
(Option.pmap f o h).toArray = Array.map (fun x => f ↑x ⋯) o.attach.toArray | true |
IntermediateField.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L] (F : IntermediateField K L),
IntermediateField.extendScalars ⋯ = ⊥ | true |
noConfusionTypeEnum | Init.Core | {α : Sort u} → {β : Sort v} → [inst : DecidableEq β] → (α → β) → Sort w → α → α → Sort w | true |
Subfield.extendScalars.orderIso._proof_5 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_1} [inst : Field L] (F : Subfield L) (E : IntermediateField (↥F) L) (x : L) (hx : x ∈ F),
(algebraMap (↥F) L) ⟨x, hx⟩ ∈ E | false |
Lean.Lsp.SemanticTokenType.leanSorryLike | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SemanticTokenType | true |
Std.DTreeMap.Raw.Const.mem_iff_isSome_get? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, a ∈ t ↔ (Std.DTreeMap.Raw.Const.get? t a).isSome = true | true |
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.listTransvecCol_mul_last_col._simp_1_7 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
ZetaAsymptotics.zeta_limit_aux1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℝ}, 1 < s → ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1) = 1 - s * ZetaAsymptotics.term_tsum s | true |
Std.Internal.Async.IO.AsyncWrite.mk.noConfusion | Std.Internal.Async.IO | {α β : Type} →
{P : Sort u} →
{write : α → β → Std.Internal.IO.Async.Async Unit} →
{writeAll : α → Array β → Std.Internal.IO.Async.Async Unit} →
{flush : α → Std.Internal.IO.Async.Async Unit} →
{write' : α → β → Std.Internal.IO.Async.Async Unit} →
{writeAll' : α → Array β → Std.Internal.IO.Async.Async Unit} →
{flush' : α → Std.Internal.IO.Async.Async Unit} →
{ write := write, writeAll := writeAll, flush := flush } =
{ write := write', writeAll := writeAll', flush := flush' } →
(write ≍ write' → writeAll ≍ writeAll' → flush ≍ flush' → P) → P | false |
Subfield.copy._proof_6 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (S : Subfield K) (s : Set K), s = ↑S → ∀ x ∈ s, x⁻¹ ∈ s | false |
Lean.IR.EmitLLVM.emitDel | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → LLVM.Builder llvmctx → Lean.IR.VarId → Lean.IR.EmitLLVM.M llvmctx Unit | true |
List.max?_eq_some_iff' | Init.Data.List.Nat.Basic | ∀ {a : ℕ} {xs : List ℕ}, xs.max? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a | true |
PiTensorProduct.reindex_trans | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {ι₂ : Type u_2} {ι₃ : Type u_3} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] (e : ι ≃ ι₂) (e' : ι₂ ≃ ι₃),
PiTensorProduct.reindex R s e ≪≫ₗ PiTensorProduct.reindex R (fun i => s (e.symm i)) e' =
PiTensorProduct.reindex R s (e.trans e') | true |
Ordinal.mul_two | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o * 2 = o + o | true |
Polynomial.Gal.instUniqueOfFactSplits | Mathlib.FieldTheory.PolynomialGaloisGroup | {F : Type u_1} → [inst : Field F] → (p : Polynomial F) → [h : Fact p.Splits] → Unique p.Gal | true |
Matroid.loopyOn_isBasis_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, (Matroid.loopyOn E).IsBasis I X ↔ I = ∅ ∧ X ⊆ E | true |
_private.Mathlib.Order.Antichain.0.IsMaxAntichain.nonempty_iff._simp_1_1 | Mathlib.Order.Antichain | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | false |
EsakiaHom.toPseudoEpimorphism | Mathlib.Topology.Order.Hom.Esakia | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : Preorder α] →
[inst_2 : TopologicalSpace β] → [inst_3 : Preorder β] → EsakiaHom α β → PseudoEpimorphism α β | true |
IndepMatroid.ofFinitaryCardAugment_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop) (indep_empty : Indep ∅)
(indep_subset : ∀ ⦃I J : Set α⦄, Indep J → I ⊆ J → Indep I)
(indep_aug :
∀ ⦃I J : Set α⦄, Indep I → I.Finite → Indep J → J.Finite → I.ncard < J.ncard → ∃ e ∈ J, e ∉ I ∧ Indep (insert e I))
(indep_compact : ∀ (I : Set α), (∀ J ⊆ I, J.Finite → Indep J) → Indep I)
(subset_ground : ∀ (I : Set α), Indep I → I ⊆ E),
(IndepMatroid.ofFinitaryCardAugment E Indep indep_empty indep_subset indep_aug indep_compact subset_ground).E = E | true |
ZLattice.sum_piFinset_Icc_rpow_le | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{L : Submodule ℤ E} [inst_3 : DiscreteTopology ↥L] {ι : Type u_3} [inst_4 : Fintype ι] [inst_5 : DecidableEq ι]
(b : Module.Basis ι ℤ ↥L) {d : ℕ},
d = Fintype.card ι →
∀ (n : ℕ),
∀ r < -↑d,
∑ p ∈ Fintype.piFinset fun x => Finset.Icc (-↑n) ↑n, ‖∑ i, p i • b i‖ ^ r ≤
2 * ↑d * 3 ^ (d - 1) * ZLattice.normBound b ^ r * ∑' (k : ℕ), ↑k ^ (↑d - 1 + r) | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_5 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(φ : L.BoundedFormula α (x + 1)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 :
(n l : ℕ) →
(R : L.Relations l) → (ts : Fin l → L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.rel R ts))
(h_4 : (x : ℕ) → (φ₁ φ₂ : L.BoundedFormula α x) → motive x (φ₁.imp φ₂))
(h_5 : (x : ℕ) → (φ : L.BoundedFormula α (x + 1)) → motive x φ.all),
(match x, φ.all with
| n, FirstOrder.Language.BoundedFormula.falsum => h_1 n
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => h_2 x t₁ t₂
| n, FirstOrder.Language.BoundedFormula.rel R ts => h_3 n l R ts
| x, φ₁.imp φ₂ => h_4 x φ₁ φ₂
| x, φ.all => h_5 x φ) =
h_5 x φ | true |
Lean.Elab.instInhabitedDefViewElabHeaderData.default | Lean.Elab.DefView | Lean.Elab.DefViewElabHeaderData | true |
CochainComplex.mappingCone.mapOfHomotopy | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K₁ L₁ K₂ L₂ : CochainComplex C ℤ} →
{φ₁ : K₁ ⟶ L₁} →
{φ₂ : K₂ ⟶ L₂} →
{a : K₁ ⟶ K₂} →
{b : L₁ ⟶ L₂} →
Homotopy (CategoryTheory.CategoryStruct.comp φ₁ b) (CategoryTheory.CategoryStruct.comp a φ₂) →
(CochainComplex.mappingCone φ₁ ⟶ CochainComplex.mappingCone φ₂) | true |
DivisionRing.nnratCast_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionRing K] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | true |
IsLocalization.noZeroDivisors | 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] [IsLocalization M S] [NoZeroDivisors R], NoZeroDivisors S | true |
Std.OrientedCmp.not_isGE_of_gt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.gt → ¬(cmp b a).isGE = true | true |
CategoryTheory.Localization.lift₂NatIso.eq_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_3} {D₂ : Type u_4} {E : 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} D₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₂]
[inst_4 : CategoryTheory.Category.{v_5, u_5} E] (L₁ : CategoryTheory.Functor C₁ D₁)
(L₂ : CategoryTheory.Functor C₂ D₂) (W₁ : CategoryTheory.MorphismProperty C₁)
(W₂ : CategoryTheory.MorphismProperty C₂) [inst_5 : L₁.IsLocalization W₁] [inst_6 : L₂.IsLocalization W₂]
[inst_7 : W₁.ContainsIdentities] [inst_8 : W₂.ContainsIdentities]
(F₁ F₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ E))
(F₁' F₂' : CategoryTheory.Functor D₁ (CategoryTheory.Functor D₂ E))
[inst_9 : CategoryTheory.Localization.Lifting₂ L₁ L₂ W₁ W₂ F₁ F₁']
[inst_10 : CategoryTheory.Localization.Lifting₂ L₁ L₂ W₁ W₂ F₂ F₂'] (e : F₁ ≅ F₂),
CategoryTheory.Localization.lift₂NatIso L₁ L₂ W₁ W₂ F₁ F₂ F₁' F₂' e =
{ hom := CategoryTheory.Localization.lift₂NatTrans L₁ L₂ W₁ W₂ F₁ F₂ F₁' F₂' e.hom,
inv := CategoryTheory.Localization.lift₂NatTrans L₁ L₂ W₁ W₂ F₂ F₁ F₂' F₁' e.inv, hom_inv_id := ⋯,
inv_hom_id := ⋯ } | true |
Continuous.cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | false |
Std.Time.Modifier.Z | Std.Time.Format.Basic | Std.Time.OffsetZ → Std.Time.Modifier | true |
Lean.Lsp.instToJsonInlayHintKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InlayHintKind → Sort u_1) →
(x : Lean.Lsp.InlayHintKind) →
(Unit → motive Lean.Lsp.InlayHintKind.type) → (Unit → motive Lean.Lsp.InlayHintKind.parameter) → motive x | false |
differentiableAt_add_const_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} (c : F), DifferentiableAt 𝕜 (fun y => f y + c) x = DifferentiableAt 𝕜 f x | false |
Lean.Meta.Occurrences.rec | Init.MetaTypes | {motive : Lean.Meta.Occurrences → Sort u} →
motive Lean.Meta.Occurrences.all →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.pos idxs)) →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.neg idxs)) → (t : Lean.Meta.Occurrences) → motive t | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Basic.0.MeasureTheory.le_iInf_lintegral._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_8} {β : α → Type u_9} {ι : Sort u_10} [inst : (i : α) → InfSet (β i)] {f : ι → (a : α) → β a} {a : α},
⨅ i, f i a = (⨅ i, f i) a | false |
Real.Wallis.W._proof_1 | Mathlib.Analysis.Real.Pi.Wallis | (1 + 1).AtLeastTwo | false |
CategoryTheory.GradedObject.mapBifunctorMapMapIso._proof_1 | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_2, u_3} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_8} {J : Type u_9} {K : Type u_1}
(p : I × J → K) {X₁ X₂ : CategoryTheory.GradedObject I C₁} {Y₁ Y₂ : CategoryTheory.GradedObject J C₂}
[inst_3 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₁).obj Y₁).HasMap p]
[inst_4 : (((CategoryTheory.GradedObject.mapBifunctor F I J).obj X₂).obj Y₂).HasMap p] (e : X₁ ≅ X₂) (e' : Y₁ ≅ Y₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapBifunctorMapMap F p e.hom e'.hom)
(CategoryTheory.GradedObject.mapBifunctorMapMap F p e.inv e'.inv) =
CategoryTheory.CategoryStruct.id (CategoryTheory.GradedObject.mapBifunctorMapObj F p X₁ Y₁) | false |
Set.one_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : One α] {s : Set α}, 1 ⊆ s ↔ 1 ∈ s | true |
Std.ExtDTreeMap.Const.ordered_keys_toList | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp],
List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) (Std.ExtDTreeMap.Const.toList t) | true |
Batteries.Tactic.Instances._aux_Batteries_Tactic_Instances___elabRules_Batteries_Tactic_Instances_instancesCmd_1 | Batteries.Tactic.Instances | Lean.Elab.Command.CommandElab | false |
LowerSemicontinuousWithinAt.inv | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} [inst : TopologicalSpace α] {β : Type u_5} {f : α → β} {s : Set α} {a : α} [inst_1 : PartialOrder β]
[inst_2 : CommGroup β] [IsOrderedMonoid β], LowerSemicontinuousWithinAt f s a → UpperSemicontinuousWithinAt f⁻¹ s a | true |
Lean.Elab.Tactic.Omega.Justification.combine.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ {s t : Lean.Omega.Constraint} {c : Lean.Omega.Coeffs} (j : Lean.Elab.Tactic.Omega.Justification s c)
(k : Lean.Elab.Tactic.Omega.Justification t c),
sizeOf (j.combine k) = 1 + sizeOf s + sizeOf t + sizeOf c + sizeOf j + sizeOf k | true |
Monoid.Coprod.swap_eq_one._simp_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {x : Monoid.Coprod M N},
((Monoid.Coprod.swap M N) x = 1) = (x = 1) | false |
Fin.cast_rev | Mathlib.Data.Fin.Rev | ∀ {n m : ℕ} (i : Fin n) (h : n = m), Fin.cast h i.rev = (Fin.cast h i).rev | true |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearMap.fixedSubmodule_eq_ker._simp_1_1 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.instReprSupportedTermKind.repr.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | (motive : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind✝ → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind✝¹) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.add✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.num✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.div✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mod✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.sub✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.pow✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbs✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toNat✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natCast✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.neg✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toInt✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.finVal✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.finMk✝) → motive x | false |
FP.RMode.NE.sizeOf_spec | Mathlib.Data.FP.Basic | sizeOf FP.RMode.NE = 1 | true |
Std.DTreeMap.Raw.Const.getD_inter_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF → m₂.WF → ∀ {k : α} {fallback : β}, k ∉ m₁ → Std.DTreeMap.Raw.Const.getD (m₁ ∩ m₂) k fallback = fallback | true |
CategoryTheory.Bicategory.instIsIsoHomLeftZigzagHom | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(η : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g)
(ε : CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b),
CategoryTheory.IsIso (CategoryTheory.Bicategory.leftZigzag η.hom ε.hom) | true |
Lean.LocalContext.findDecl? | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → Option β) → Option β | true |
_private.Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite.0.CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.generator | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type v} →
[inst_1 : CategoryTheory.SmallCategory D] →
CategoryTheory.Functor D Cᵒᵖ →
[inst_2 : CategoryTheory.Abelian C] → [CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] → Cᵒᵖ | true |
Lists'.mem_of_subset' | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁.toList → a ∈ l₂ | true |
_private.Mathlib.Data.Finset.NatDivisors.0.Nat.divisors_mul._simp_1_2 | Mathlib.Data.Finset.NatDivisors | ∀ {n m : ℕ}, (n ∈ m.divisors) = (n ∣ m ∧ m ≠ 0) | false |
ModP.preVal_eq_zero | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} {x : ModP O p}, ModP.preVal K v O p x = 0 ↔ x = 0 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.