name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Topology.UnitInterval.0.unitInterval.image_coe_preimage_symm._simp_1_1 | Mathlib.Topology.UnitInterval | Function.Involutive unitInterval.symm = True | false |
HahnSeries.SummableFamily.instAddCommGroup | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
[inst : PartialOrder Γ] → [inst_1 : AddCommGroup R] → AddCommGroup (HahnSeries.SummableFamily Γ R α) | true |
withSeminorms_iInf | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{κ : ι → Type u_11} {p : (i : ι) → SeminormFamily 𝕜 E (κ i)} {t : ι → TopologicalSpace E},
(∀ (i : ι), WithSeminorms (p i)) → WithSeminorms (SeminormFamily.sigma p) | true |
with_gaugeSeminormFamily | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
[IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [LocallyConvexSpace 𝕜 E], WithSeminorms (gaugeSemino... | true |
CategoryTheory.Functor.mapArrowEquivalence._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (e : C ≌ D) (X : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp
(e.functor.mapArrow.map (((CategoryTheory.Functor.mapArrowFunctor C C).mapIso e.unitIso).hom.app X))
... | false |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.ruzsaSzemerediNumberNat_asymptotic_lower_bound._simp_1_2 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
Submonoid.unitsEquivUnitsType._proof_6 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (x x_1 : ↥S.units),
(match x * x_1 with
| ⟨val, h⟩ =>
{ val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHom M) val⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ }) =
match x * x_1 with
| ⟨val, h⟩ => { val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHo... | false |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.IsEquiv.valueGroup₀Fun_spec._simp_1_2 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u} {a b : α}, (↑a = ↑b) = (a = b) | false |
CommBialgCat._sizeOf_1 | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → {inst : CommRing R} → [SizeOf R] → CommBialgCat R → ℕ | false |
Int64.ofIntLE_eq_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int64.minValue.toInt ≤ x} {h₂ : x ≤ Int64.maxValue.toInt}, Int64.ofIntLE x h₁ h₂ = Int64.ofIntTruncate x | true |
Mathlib.Explode.Entry.type | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entry → Lean.MessageData | true |
_private.Mathlib.Analysis.Normed.Affine.Simplex.0.Affine.Simplex.scalene_reindex_iff._proof_1_8 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {m n : ℕ} (e : Fin (m + 1) ≃ Fin (n + 1)) (fst snd : Fin (m + 1)) (property : fst < snd),
e fst < e snd →
(e.symm (↑(if h : e fst < e snd then ⟨(e fst, e snd), ⋯⟩ else ⟨(e snd, e fst), ⋯⟩)).1,
e.symm (↑(if h : e fst < e snd then ⟨(e fst, e snd), ⋯⟩ else ⟨(e snd, e fst), ⋯⟩)).2).1 <
(e.symm (↑(if... | false |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.instAddGroup._simp_6 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a b : G →₀ k},
{ toFinsupp := a } + { toFinsupp := b } = { toFinsupp := a + b } | false |
Lean.Elab.Tactic.Omega.Fact.mk.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ (coeffs : Lean.Omega.Coeffs) (constraint : Lean.Omega.Constraint)
(justification : Lean.Elab.Tactic.Omega.Justification constraint coeffs),
sizeOf { coeffs := coeffs, constraint := constraint, justification := justification } =
1 + sizeOf coeffs + sizeOf constraint + sizeOf justification | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.nhdsWithin_bot.match_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x : ℝ) (x_1 : EReal) (motive : x_1 ∈ Set.Ioc ⊥ ↑x → Prop) (x_2 : x_1 ∈ Set.Ioc ⊥ ↑x),
(∀ (h1 : ⊥ < x_1) (h2 : x_1 ≤ ↑x), motive ⋯) → motive x_2 | false |
Lean.Parser.Command.in._regBuiltin.Lean.Parser.Command.in.parenthesizer_11 | Lean.Parser.Command | IO Unit | false |
WeierstrassCurve.natDegree_Φ_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [Nontrivial R] {n : ℤ}, n ≠ 0 → 0 < (W.Φ n).natDegree | true |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnaryUInt8 | Lean.Meta.Sym.Simp.EvalGround | (UInt8 → UInt8) → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
SSet.Truncated.HomotopyCategory.homMk_comp_homMk_assoc | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
{x₀ x₁ x₂ : V.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 })}
{e₀₁ : SSet.Truncated.Edge x₀ x₁} {e₁₂ : SSet.Truncated.Edge x₁ x₂} {e₀₂ : SSet.Truncated.Edge x₀ x₂}
(h : e₀₁.CompStruct e₁₂ e₀₂) {Z : V.HomotopyCategory} (h : SSet.Truncated.Homoto... | true |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkNoConfusion.match_1 | Lean.Meta.AppBuilder | (motive : Option (Lean.ConstructorVal × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.ConstructorVal × Array Lean.Expr)) →
((ctorB : Lean.ConstructorVal) → (ys2 : Array Lean.Expr) → motive (some (ctorB, ys2))) →
((x : Option (Lean.ConstructorVal × Array Lean.Expr)) → motive x) → motive __do_lift | false |
Algebra.Extension.cotangentComplex | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → (P : Algebra.Extension R S) → P.Cotangent →ₗ[S] P.CotangentSpace | true |
MonoidWithZeroHom.fst_apply_coe | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ {G₀ : Type u_1} {H₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀] (x : G₀ˣ × H₀ˣ),
(MonoidWithZeroHom.fst G₀ H₀) ↑x = ↑x.1 | true |
DoubleCentralizer.natCast_toProd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (n : ℕ), (↑n).toProd = ↑n | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
CategoryTheory.ComposableArrows.Mk₁.map.eq_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) (isLt isLt_1 : 1 < 2)
(x_3 : ⟨1, isLt⟩ ≤ ⟨1, isLt_1⟩),
CategoryTheory.ComposableArrows.Mk₁.map f ⟨1, isLt⟩ ⟨1, isLt_1⟩ x_3 =
CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ ⟨1, isLt⟩) | true |
AbsoluteValue.trivial._proof_3 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : DecidablePred fun x => x = 0] {S : Type u_1} [inst_2 : Semiring S]
[Nontrivial S] (x : R), (if x = 0 then 0 else 1) = 0 ↔ x = 0 | false |
HomologicalComplex.homology.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Acyclic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K K_1 : HomologicalComplex C c) (e_K : K = K_1) (i i_1 : ι) (e_i : i = i_1)
[inst_2 : K.HasHomology i], K.homology i = K_1.homology i_1 | true |
CategoryTheory.HasInjectiveResolutions.mk._flat_ctor | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C],
(∀ (Z : C), CategoryTheory.HasInjectiveResolution Z) → CategoryTheory.HasInjectiveResolutions C | false |
NumberField.ComplexEmbedding.LiesOver.mk | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {φ : L →+* ℂ} {ψ : K →+* ℂ},
φ.comp (algebraMap K L) = ψ → NumberField.ComplexEmbedding.LiesOver φ ψ | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.shortCircuitPass.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit | (motive : Option (Array Lean.FVarId × Lean.MVarId) → Sort u_1) →
(result? : Option (Array Lean.FVarId × Lean.MVarId)) →
((fst : Array Lean.FVarId) → (newGoal : Lean.MVarId) → motive (some (fst, newGoal))) →
((x : Option (Array Lean.FVarId × Lean.MVarId)) → motive x) → motive result? | false |
Nat.isSome_getElem?_toArray_ric_eq | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, ((*...=n).toArray[i]?.isSome = true) = (i ≤ n) | true |
Lean.IR.EmitLLVM.getEnv | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → Lean.IR.EmitLLVM.M llvmctx Lean.Environment | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR._simp_4 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ {α : Type u_1} {a : α} {s : Multiset α}, (a ::ₘ s).Nodup = (a ∉ s ∧ s.Nodup) | false |
Lean.Meta.Grind.Order.Struct.mk.noConfusion | Lean.Meta.Tactic.Grind.Order.Types | {P : Sort u} →
{id : ℕ} →
{type : Lean.Expr} →
{u : Lean.Level} →
{isPreorderInst leInst : Lean.Expr} →
{ltInst? isPartialInst? isLinearPreInst? lawfulOrderLTInst? : Option Lean.Expr} →
{ringId? : Option ℕ} →
{isCommRing : Bool} →
{ringInst? ordere... | false |
Function.Injective.leftCancelMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : LeftCancelMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
... | true |
Std.DTreeMap.Internal.Impl.toList_filter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {f : (a : α) → β a → Bool},
t.WF → (Std.DTreeMap.Internal.Impl.filter! f t).toList = List.filter (fun p => f p.fst p.snd) t.toList | true |
CategoryTheory.AddMonObj.zero_associator | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N P : C}
[inst_2 : CategoryTheory.AddMonObj M] [inst_3 : CategoryTheory.AddMonObj N] [inst_4 : CategoryTheory.AddMonObj P],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
... | true |
Equiv.sumArrowEquivProdArrow._proof_1 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_3) (β : Type u_1) (γ : Type u_2) (f : α ⊕ β → γ),
(fun p => Sum.elim p.1 p.2) ((fun f => (f ∘ Sum.inl, f ∘ Sum.inr)) f) = f | false |
Module.Baer.ExtensionOfMaxAdjoin.ideal._proof_1 | Mathlib.Algebra.Module.Injective | ∀ {R : Type u_1} [inst : Ring R] {N : Type u_2} [inst_1 : AddCommGroup N] [inst_2 : Module R N], IsScalarTower R R N | false |
Aesop.RuleApplication.successProbability? | Aesop.RuleTac.Basic | Aesop.RuleApplication → Option Aesop.Percent | true |
Nat.range_succ_eq_Iic | Mathlib.Order.Interval.Finset.Nat | ∀ (n : ℕ), Finset.range (n + 1) = Finset.Iic n | true |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.AddSubmonoid.map_id.match_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : AddZeroClass M] (S : AddSubmonoid M) (x : M)
(motive : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S → Prop) (x_1 : x ∈ AddSubmonoid.map (AddMonoidHom.id M) S),
(∀ (h : x ∈ ↑S), motive ⋯) → motive x_1 | false |
Lean.Elab.Structural.IndGroupInst.toMessageData | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInst → Lean.MessageData | true |
List.all_one_of_le_one_le_of_prod_eq_one | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : CommMonoid M] [inst_1 : PartialOrder M] [IsOrderedMonoid M] {l : List M},
(∀ x ∈ l, 1 ≤ x) → l.prod = 1 → ∀ {x : M}, x ∈ l → x = 1 | true |
ClopenUpperSet.noConfusion | Mathlib.Topology.Sets.Order | {P : Sort u} →
{α : Type u_2} →
{inst : TopologicalSpace α} →
{inst_1 : LE α} →
{t : ClopenUpperSet α} →
{α' : Type u_2} →
{inst' : TopologicalSpace α'} →
{inst'_1 : LE α'} →
{t' : ClopenUpperSet α'} →
α = α' → inst ≍ inst' → inst... | false |
_private.Mathlib.Algebra.FiniteSupport.Basic.0.Function.HasFiniteMulSupport.pi._simp_1_1 | Mathlib.Algebra.FiniteSupport.Basic | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {x : ι}, (x ∈ Function.mulSupport f) = (f x ≠ 1) | false |
Urysohns.CU.approx.match_1 | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} →
[inst : TopologicalSpace X] →
{P : Set X → Set X → Prop} →
(motive : ℕ → Urysohns.CU P → X → Sort u_2) →
(x : ℕ) →
(x_1 : Urysohns.CU P) →
(x_2 : X) →
((c : Urysohns.CU P) → (x : X) → motive 0 c x) →
((n : ℕ) → (c : Urysohns.CU P) ... | false |
CategoryTheory.PreOneHypercover.isoMk_inv_s₀ | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreOneHypercover S}
(s₀ : E.I₀ ≃ F.I₀) (h₀ : (i : E.I₀) → E.X i ≅ F.X (s₀ i)) (s₁ : ⦃i j : E.I₀⦄ → E.I₁ i j ≃ F.I₁ (s₀ i) (s₀ j))
(h₁ : ⦃i j : E.I₀⦄ → (k : E.I₁ i j) → E.Y k ≅ F.Y (s₁ k))
(w₀ :
autoParam (∀ (i : E.I₀), Cate... | true |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_1} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_2))
(p : ↑(MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)))) {j j' : CategoryTheory.SingleObj M},
↑p ∈ MulAction.fixedPoints M (J.obj (CategoryTheory.SingleObj.star M)) | false |
Lean.Elab.Tactic.Do.ProofMode.elabMExact | Lean.Elab.Tactic.Do.ProofMode.Exact | Lean.Elab.Tactic.Tactic | true |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.absolutelyContinuous_of_compProd._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ Set.univ = 0) = (μ = 0) | false |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.coe_range_dense._simp_1_2 | Mathlib.RingTheory.LaurentSeries | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
Lean.Compiler.LCNF.instantiateRangeArgs | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Expr → ℕ → ℕ → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Expr | true |
SpectrumRestricts.starAlgHom_injective | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Semifield S] [inst_6 : StarRing S]
[inst_7 : MetricSpace S] [inst_8 : IsTopologicalSemiring S] [inst_9 : ContinuousStar S] [inst... | true |
AddCircle.homeomorphAddCircle_symm_apply_mk | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p q : 𝕜) [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [inst_4 : OrderTopology 𝕜] (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜),
(AddCircle.homeomorphAddCircle p q hp hq).symm ↑x = ↑(x * (q⁻¹ * p)) | true |
ZeroAtInftyContinuousMap.coe_zero | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β], ⇑0 = 0 | true |
_private.Init.Grind.Module.Envelope.0.Lean.Grind.IntModule.OfNatModule.rel | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
Equivalence (Lean.Grind.IntModule.OfNatModule.r α) →
Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α → Prop | true |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.projective_of_finitePresentation.match_1_1 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂) → Prop) (x : ∃ k h₂ h₃, LinearMap.id = h₃ ∘ₗ h₂),
(∀ (w : ℕ) (f : M →ₗ[R] Fin w →₀ R) (g : (Fin w →₀ R) →ₗ[R] M) (eq : LinearMap.id = g ∘ₗ f), motive ⋯) → motive x | false |
Module.finitePresentation_iff_finite | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsNoetherianRing R],
Module.FinitePresentation R M ↔ Module.Finite R M | true |
AddMonoidAlgebra.ofMagma_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ (R : Type u_8) (M : Type u_9) [inst : Semiring R] [inst_1 : Add M] (a : Multiplicative M),
(AddMonoidAlgebra.ofMagma R M) a = AddMonoidAlgebra.single (Multiplicative.toAdd a) 1 | true |
FilterBasis | Mathlib.Order.Filter.Bases.Basic | Type u_6 → Type u_6 | true |
List.le_max_of_mem | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α] {l : List α} {a : α}
(ha : a ∈ l), a ≤ l.max ⋯ | true |
bind_pure_unit | Init.Control.Lawful.Basic | ∀ {m : Type u_1 → Type u_2} [inst : Monad m] [LawfulMonad m] {x : m PUnit.{u_1 + 1}},
(do
x
pure PUnit.unit) =
x | true |
rank_eq_card_basis | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type w} [inst_4 : Fintype ι] (h : Module.Basis ι R M), Module.rank R M = ↑(Fintype.card ι) | true |
MultilinearMap.currySum._proof_7 | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type u_5} {ι : Type u_2} {ι' : Type u_1} {M₂ : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] {N : ι ⊕ ι' → Type u_4} [inst_3 : (i : ι ⊕ ι') → AddCommMonoid (N i)]
[inst_4 : (i : ι ⊕ ι') → Module R (N i)] (f : MultilinearMap R N M₂) [inst_5 : DecidableEq ι]
(u : (i : ι... | false |
MeasureTheory.measurePreserving_pi_empty | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u} {α : ι → Type v} [inst : Fintype ι] [inst_1 : IsEmpty ι] {m : (i : ι) → MeasurableSpace (α i)}
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit))
(MeasureTheory.Measure.pi μ) (MeasureTheory.Measure.dirac ()) | true |
definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [FiniteDimensional 𝕜 E] {n : ℕ},
Module.finrank 𝕜 E = n →
∀ [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
DirectSum.IsInternal V →
(Ortho... | false |
BoundedContinuousFunction.rec | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
{motive : BoundedContinuousFunction α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(map_bounded' : ∃ C, ∀ (x y : α), dist (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C) →
... | false |
CategoryTheory.ShortComplex.opcyclesFunctor | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasKernels C] →
[CategoryTheory.Limits.HasCokernels C] → CategoryTheory.Functor (CategoryTheory.ShortComplex C) C | true |
monovaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
MonovaryOn (-f) (-g) s ↔ MonovaryOn f g s | true |
Lean.Elab.Term.elabLetDelayedDecl | Lean.Elab.Binders | Lean.Elab.Term.TermElab | true |
Array.appendCore.loop | Init.Prelude | {α : Type u} → Array α → ℕ → ℕ → Array α → Array α | true |
Subgroup.FG.eq_1 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG = ∃ S, Subgroup.closure ↑S = P | true |
instDecidableEqColex | Mathlib.Order.Lex | (α : Type u_2) → [h : DecidableEq α] → DecidableEq (Colex α) | true |
AlgEquiv.aut._proof_8 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(x : A₁ ≃ₐ[R] A₁), 1 * x = x | false |
Lean.Server.Test.Runner.rpcRequest | Lean.Server.Test.Runner | {α : Type u_1} → Lean.Name → [Lean.ToJson α] → α → (β : Type) → [Lean.FromJson β] → Lean.Server.Test.Runner.RunnerM β | true |
MulEquiv.toMonCatIso | Mathlib.Algebra.Category.MonCat.Basic | {X Y : Type u} → [inst : Monoid X] → [inst_1 : Monoid Y] → X ≃* Y → (MonCat.of X ≅ MonCat.of Y) | true |
InfClosed.infClosure_eq | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeInf α] {s : Set α}, InfClosed s → infClosure s = s | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | true |
AlgebraicGeometry.IsLocallyArtinian.discreteTopology_of_isAffine | Mathlib.AlgebraicGeometry.Artinian | ∀ {X : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsLocallyArtinian X], DiscreteTopology ↥X | true |
Lean.Meta.Tactic.Cbv.getMatchTheorems | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Name → Lean.MetaM Lean.Meta.Sym.Simp.Theorems | true |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_21 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam
(∀ (n_1 : ℕ) (a : X.EllAdicCohomology ℓ n),
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n (Int.negSucc n_1) a =
-AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n... | false |
CategoryTheory.Bicategory.Adj.iso₂Mk._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
(el : α.l ≅ β.l) (er : β.r ≅ α.r),
(CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) el.hom = er.hom →
(CategoryTheory.Bicategory.conjugateEquiv α.adj β.adj) el.inv = er.inv | false |
String.Slice.Pos.byte.eq_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos) (h : pos ≠ s.endPos), pos.byte h = s.getUTF8Byte pos.offset ⋯ | true |
CategoryTheory.Monoidal.InducingFunctorData.rec | Mathlib.CategoryTheory.Monoidal.Transport | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategoryStruct D] →
{F : CategoryTheory.Functor D C} →
{mo... | false |
Mathlib.Linter.linter.style.setOption | Mathlib.Tactic.Linter.Style | Lean.Option Bool | true |
CategoryTheory.ULift.upFunctor | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (ULift.{u₂, u₁} C) | true |
Mathlib.Tactic.filterUpwards | Mathlib.Order.Filter.Defs | Lean.ParserDescr | true |
instTotallyDisconnectedSpaceMultiplicative | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α], TotallyDisconnectedSpace (Multiplicative α) | true |
BooleanAlgebra.toBooleanRing._proof_5 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (n : ℕ), (↑n).castDef = ↑n | false |
Module.Finite.addMonoidHom | Mathlib.LinearAlgebra.FreeModule.Finite.Matrix | ∀ (M : Type v) (N : Type w) [inst : AddCommGroup M] [Module.Finite ℤ M] [Module.Free ℤ M] [inst_3 : AddCommGroup N]
[Module.Finite ℤ N], Module.Finite ℤ (M →+ N) | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c_1) =
(c = c_1) | true |
Lean.Core.Context.cancelTk? | Lean.CoreM | Lean.Core.Context → Option IO.CancelToken | true |
_private.Batteries.Data.List.Lemmas.0.List.dropPrefix?.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (list : List α) (h_1 : (list : List α) → motive list [])
(h_2 : (head : α) → (tail : List α) → motive [] (head :: tail))
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match list, [] with
| list, [] => h_1 list
... | true |
SimpleGraph.Subgraph.Connected.mono' | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph},
(∀ (v w : V), H.Adj v w → H'.Adj v w) → H.verts = H'.verts → H.Connected → H'.Connected | true |
dvd_mul_gcd_of_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ m * n → k ∣ m * gcd k n | true |
CategoryTheory.GlueData.mk | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
(J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
autoParam (∀ (i j : J), CategoryTheory.Mono (f i j)) CategoryTheory.GlueData.f_mono._autoParam →
(f_hasPullback :
... | true |
Std.Rio.mem_iff_mem_Rco | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Rio α} [inst : LE α] [inst_1 : LT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α] [Std.Rxo.IsAlwaysFinite α] {a : α},
a ∈ r ↔ a ∈ ... | true |
Filter.div_le_div_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f₁ f₂ g : Filter α}, f₁ ≤ f₂ → f₁ / g ≤ f₂ / g | true |
_private.Mathlib.Analysis.PSeries.0.Real.summable_nat_rpow_inv._simp_1_1 | Mathlib.Analysis.PSeries | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.