name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.Nat.Lemmas.0.Nat.lt_div_iff_mul_lt_of_dvd._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) | false |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.Sum.mem_uniformity_iff_glueDist._simp_1_5 | Mathlib.Topology.MetricSpace.Gluing | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | false |
ConvexCone.strictlyPositive._proof_2 | Mathlib.Geometry.Convex.Cone.Basic | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : PartialOrder M] [IsOrderedAddMonoid M],
∀ x ∈ Set.Ioi 0, ∀ x_1 ∈ Set.Ioi 0, 0 < x + x_1 | false |
Lean.Elab.Command.Structure.StructParentInfo._sizeOf_inst | Lean.Elab.Structure | SizeOf Lean.Elab.Command.Structure.StructParentInfo | false |
CategoryTheory.MonObj.one_mul_hom_assoc | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M : C}
[inst_2 : CategoryTheory.MonObj M] {Z : C} (f : Z ⟶ M) {Z_1 : C} (h : M ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.MonObj.one f)
(Cat... | true |
CategoryTheory.Limits.piObjIso._proof_3 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Products | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] {α : Type u_1}
[CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete α) C] (f : α → CategoryTheory.Functor D C) (d : D),
CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.... | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.exists_presentation_of_basis_cotangent._simp_1_1 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u} [inst : Semiring R] {I J : Ideal R}, (I * J ≤ J) = True | false |
Lean.Elab.Tactic.Omega.State.noConfusionType | Lean.Elab.Tactic.Omega.OmegaM | Sort u → Lean.Elab.Tactic.Omega.State → Lean.Elab.Tactic.Omega.State → Sort u | false |
LieAlgebra.ofAbelianIsSolvable | Mathlib.Algebra.Lie.Solvable | ∀ (L : Type v) [inst : LieRing L] [IsLieAbelian L], LieAlgebra.IsSolvable L | true |
Std.HashSet.Raw.WF.erase | Std.Data.HashSet.Raw | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashSet.Raw α} {a : α}, m.WF → (m.erase a).WF | true |
List.head_attach._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α}, xs.attach ≠ [] → xs ≠ [] | false |
CFC.IsSelfAdjoint.norm_mul_mul_self_of_nonneg._auto_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | Lean.Syntax | false |
LinearMap.BilinForm.ext_of_isSymm | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {M : Type u_2} [inst : AddCommMonoid M] {R : Type u_8} [inst_1 : Field R] [NeZero 2] [inst_3 : Module R M]
{B C : LinearMap.BilinForm R M}, B.IsSymm → C.IsSymm → (∀ (x : M), (B x) x = (C x) x) → B = C | true |
CategoryTheory.PreOneHypercover.Hom.mapMultiforkOfIsLimit._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {A : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} A] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (P : CategoryTheory.Functor Cᵒᵖ A)
(d : CategoryTheory.Limits.Multifork (F.multicospan... | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap.0.Std.IterM.flatMapAfterM.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : MonadAttach m] [inst_2 : Std.Iterator α m β]
[inst_3 : Std.Iterator α₂ m γ] (f : β → m (Std.IterM m γ)) (it₁ : Std.IterM m β) (it₂ : Option (Std.IterM m γ)),
Std.IterM.flatMapAfterM f it₁ it₂ = Std.IterM.flattenAfter✝ (Std.IterM.mapM f it₁) it₂ | true |
Lean.PrettyPrinter.initFn._@.Lean.PrettyPrinter.Formatter.4150507199._hygCtx._hyg.2 | Lean.PrettyPrinter.Formatter | IO Lean.ParserCompiler.CombinatorAttribute | false |
Lean.Meta.Grind.Goal.extThms._inherited_default | Lean.Meta.Tactic.Grind.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr (Array Lean.Meta.Ext.ExtTheorem) | false |
Complex.norm_log_one_add_half_le_self | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {z : ℂ}, ‖z‖ ≤ 1 / 2 → ‖Complex.log (1 + z)‖ ≤ 3 / 2 * ‖z‖ | true |
CategoryTheory.Bicategory.LeftExtension.IsKan.uniqueUpToIso | Mathlib.CategoryTheory.Bicategory.Kan.IsKan | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : a ⟶ b} → {g : a ⟶ c} → {s t : CategoryTheory.Bicategory.LeftExtension f g} → s.IsKan → t.IsKan → (s ≅ t) | true |
Lean.Parser.Term.doHave | Lean.Parser.Do | Lean.Parser.Parser | true |
Ordinal.CNF.rec_zero | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {C : Ordinal.{u_2} → Sort u_1} (b : Ordinal.{u_2}) (H0 : C 0)
(H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o), Ordinal.CNF.rec b H0 H 0 = H0 | true |
DoubleQuot.quotLeftToQuotSupₐ_toRingHom | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u) {A : Type u_1} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (I J : Ideal A),
↑(DoubleQuot.quotLeftToQuotSupₐ R I J) = DoubleQuot.quotLeftToQuotSup I J | true |
CategoryTheory.SpectralSequence.pageHomologyNatIso._proof_9 | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_2}
(c : ℤ → ComplexShape κ) (r₀ r r' : ℤ) (pq : κ) (hrr' : r + 1 = r') (hr : r₀ ≤ r)
{X Y : CategoryTheory.SpectralSequence C c r₀} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory... | false |
CategoryTheory.CartesianMonoidalCategory.ofChosenFiniteProducts.id_tensorHom_id | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(ℬ : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) (X Y : C),
CategoryTheory.CartesianMonoidalCategory.ofChosenFiniteProducts.tensorHom ℬ (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.CategoryStruct.id Y) =
Cat... | true |
Mathlib.Meta.FunProp.State.casesOn | Mathlib.Tactic.FunProp.Types | {motive : Mathlib.Meta.FunProp.State → Sort u} →
(t : Mathlib.Meta.FunProp.State) →
((cache : Lean.Meta.Simp.Cache) →
(failureCache : Lean.ExprSet) →
(numSteps : ℕ) →
(msgLog : List String) →
(morTheorems transitionTheorems : Mathlib.Meta.FunProp.GeneralTheorems) →
... | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.processLevel._unary._proof_12 | Lean.Meta.Sym.Pattern | ∀ (u₁ u₂ v₁ v₂ : Lean.Level),
(invImage (fun x => PSigma.casesOn x fun u v => (u, v)) Prod.instWellFoundedRelation).1 ⟨u₂, v₂⟩
⟨u₁.imax u₂, v₁.imax v₂⟩ | false |
List.Cursor.at.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} (l : List α) (n : ℕ),
List.Cursor.at l n = { «prefix» := List.take n l, suffix := List.drop n l, property := ⋯ } | true |
CategoryTheory.Bicategory.termε | Mathlib.CategoryTheory.Bicategory.Monad.Basic | Lean.ParserDescr | true |
Pi.nonAssocSemiring | Mathlib.Algebra.Ring.Pi | {I : Type u} → {f : I → Type v} → [(i : I) → NonAssocSemiring (f i)] → NonAssocSemiring ((i : I) → f i) | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.eVariationOn_eq_strictMonoOn._proof_1_7 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α) (u : ℕ → α),
(∀ (i : ℕ), u i ∈ s) →
∀ (n m : ℕ) (v : ℕ → α) (v_mono : StrictMonoOn v (Set.Iic m)) (v_mem : ∀ i ∈ Set.Iic m, v i ∈ s),
↑⟨m, ⟨v, ⋯⟩⟩.snd ⟨m, ⟨v, ⋯⟩⟩.fst = u n →
u n < u (n + 1) →
StrictMonoOn (fun i => if i ≤ m then v i else... | false |
CategoryTheory.Bicategory.Equivalence.id | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} → [inst : CategoryTheory.Bicategory B] → (a : B) → CategoryTheory.Bicategory.Equivalence a a | true |
AffineSubspace.signedInfDist_def | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : AffineSubspace ℝ P) [inst_4 : Nonempty ↥s]
[inst_5 : s.direction.HasOrthogonalProjection] (p : P),
s.signedInfDist p = (signedDist (p -ᵥ ↑((EuclideanGeometry.... | true |
Function.exists_iterate_apply_eq_of_mem_periodicPts._simp_1 | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {f : α → α} {x : α}, x ∈ Function.periodicPts f → (∃ n, f^[n] x = x) = True | false |
Module.Presentation.finsupp_relation | Mathlib.Algebra.Module.Presentation.DirectSum | ∀ {A : Type u} [inst : Ring A] {N : Type v} [inst_1 : AddCommGroup N] [inst_2 : Module A N]
(pres : Module.Presentation A N) (ι : Type w) [inst_3 : DecidableEq ι] [inst_4 : DecidableEq N]
(x : (i : ι) × ((fun i => ((fun x => pres) i).toRelations) i).R),
(pres.finsupp ι).relation x = Finsupp.embDomain (Function.Em... | true |
EquivLike.recOn | Mathlib.Data.FunLike.Equiv | {E : Sort u_1} →
{α : Sort u_2} →
{β : Sort u_3} →
{motive : EquivLike E α β → Sort u} →
(t : EquivLike E α β) →
((coe : E → α → β) →
(inv : E → β → α) →
(left_inv : ∀ (e : E), Function.LeftInverse (inv e) (coe e)) →
(right_inv : ∀ (e : E), F... | false |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_w_assoc | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | true |
Real.exp_eq_one_iff | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), Real.exp x = 1 ↔ x = 0 | true |
pointedToBipointedSndBipointedToPointedSndAdjunction._proof_2 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Pointed) (Y : Bipointed),
Function.RightInverse (fun f => { toFun := fun o => Option.elim o Y.toProd.1 f.toFun, map_fst := ⋯, map_snd := ⋯ })
fun f => { toFun := f.toFun ∘ some, map_point := ⋯ } | false |
CategoryTheory.Functor.FullyFaithful.rightOp._proof_4 | Mathlib.CategoryTheory.Opposites | ∀ {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] {F : CategoryTheory.Functor Cᵒᵖ D} (hF : F.FullyFaithful) {X Y : C}
(f : X ⟶ Y), (hF.preimage (F.rightOp.map f).unop).unop = f | false |
AddSubmonoid.mem_bot | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, x ∈ ⊥ ↔ x = 0 | true |
ProbabilityTheory.HasCondSubgaussianMGF.fun_zero | Mathlib.Probability.Moments.SubGaussian | ∀ {Ω : Type u_1} {m mΩ : MeasurableSpace Ω} {hm : m ≤ mΩ} [inst : StandardBorelSpace Ω] {μ : MeasureTheory.Measure Ω}
[inst_1 : MeasureTheory.IsFiniteMeasure μ], ProbabilityTheory.HasCondSubgaussianMGF m hm (fun x => 0) 0 μ | true |
CategoryTheory.cartesianComon._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Comon_ | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.CategoryStruct.id X))
(CategoryTheo... | false |
Nat.binaryRecFromOne_zero | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u} (zero : motive 0) (one : motive 1)
(bit : (b : Bool) → (n : ℕ) → n ≠ 0 → motive n → motive (Nat.bit b n)), Nat.binaryRecFromOne zero one bit 0 = zero | true |
PadicInt.norm_mahler_eq | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℕ), ‖mahler k‖ = 1 | true |
ContinuousMultilinearMap.norm_iteratedFDeriv_le | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {ι : Type u_2} {E : ι → Type u_3} [inst_3 : (i : ι) → NormedAddCommGroup (E i)]
[inst_4 : (i : ι) → NormedSpace 𝕜 (E i)] [inst_5 : Fintype ι] (f : ContinuousMultilinearMap 𝕜 E F) (n : ℕ)
... | true |
Lean.Meta.Grind.EMatchTheoremKind.eqBoth.elim | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
t.ctorIdx = 2 → ((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqBoth gen)) → motive t | false |
Std.Time.Internal.UnitVal.ofInt.injEq | Std.Time.Internal.UnitVal | ∀ {α : ℚ} (val val_1 : ℤ), ({ val := val } = { val := val_1 }) = (val = val_1) | true |
SSet.N.dim_lt_of_lt | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} {x y : X.N}, x < y → x.dim < y.dim | true |
Std.ExtTreeSet.get_eq_get_get? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α} {h : k ∈ t},
t.get k h = (t.get? k).get ⋯ | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit.0.CochainComplex.mappingConeHomOfDegreewiseSplitXIso._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | ∀ (p q : ℤ), p + 1 = q → q + -1 = p | false |
Lean.stateStackModify | Lean.ScopedEnvExtension | {α β σ : Type} →
Lean.ScopedEnvExtension α β σ → List (Lean.ScopedEnvExtension.State σ) → β → List (Lean.ScopedEnvExtension.State σ) | true |
_private.Mathlib.LinearAlgebra.Projectivization.Basic.0.Projectivization.equivSubmodule.match_1 | Mathlib.LinearAlgebra.Projectivization.Basic | ∀ (K : Type u_2) (V : Type u_1) [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(H : Submodule K V) (motive : H ∈ Set.range Projectivization.submodule → Prop)
(x : H ∈ Set.range Projectivization.submodule),
(∀ (v : Projectivization K V) (hv : v.submodule = H), motive ⋯) → motive x | false |
Continuous.comp_aestronglyMeasurable₂ | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace β] [inst_1 : TopologicalSpace γ]
{m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β' : Type u_5} [inst_2 : TopologicalSpace β']
{g : β → β' → γ} {f : α → β} {f' : α → β'},
Continuous (Function.uncurry g) →
MeasureTheory.AEStrongl... | true |
ByteArray.IsValidUTF8.append | Init.Data.String.Defs | ∀ {b b' : ByteArray}, b.IsValidUTF8 → b'.IsValidUTF8 → (b ++ b').IsValidUTF8 | true |
Ideal.Quotient.liftₐ._proof_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R₁ : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A]
[inst_3 : Semiring B] [inst_4 : Algebra R₁ B] (I : Ideal A) [inst_5 : I.IsTwoSided] (f : A →ₐ[R₁] B)
(hI : ∀ a ∈ I, f a = 0) (r : R₁),
(↑↑(Ideal.Quotient.lift I (↑f) hI)).toFun ((algebraMap R₁ (A ⧸ I... | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.Context.mk.injEq | Lean.Compiler.LCNF.Specialize | ∀ (scope ground underApplied : Lean.FVarIdSet) (declName : Lean.Name) (scope_1 ground_1 underApplied_1 : Lean.FVarIdSet)
(declName_1 : Lean.Name),
({ scope := scope, ground := ground, underApplied := underApplied, declName := declName } =
{ scope := scope_1, ground := ground_1, underApplied := underApplied_1,... | true |
Std.DTreeMap.Internal.Impl.getEntryDₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → (a : α) × β a → (a : α) × β a | true |
_private.Mathlib.Combinatorics.SetFamily.KruskalKatona.0.Finset.Colex.shadow_initSeg._simp_1_11 | Mathlib.Combinatorics.SetFamily.KruskalKatona | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | false |
_private.Lean.Compiler.LCNF.ResetReuse.0.Lean.Compiler.LCNF.UseClassification.recOn | Lean.Compiler.LCNF.ResetReuse | {motive : Lean.Compiler.LCNF.UseClassification✝ → Sort u} →
(t : Lean.Compiler.LCNF.UseClassification✝¹) →
motive Lean.Compiler.LCNF.UseClassification.ownedArg✝ →
motive Lean.Compiler.LCNF.UseClassification.other✝ → motive Lean.Compiler.LCNF.UseClassification.none✝ → motive t | false |
SimpleGraph.Walk.ofBoxProdRight._unsafe_rec | Mathlib.Combinatorics.SimpleGraph.Prod | {α : Type u_1} →
{β : Type u_2} →
{G : SimpleGraph α} →
{H : SimpleGraph β} → [DecidableEq α] → [DecidableRel H.Adj] → {x y : α × β} → (G □ H).Walk x y → H.Walk x.2 y.2 | false |
CategoryTheory.ComposableArrows.exact_iff_δlast._proof_5 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ}, n + 2 ≤ n + 2 | false |
RingQuot.instRing._proof_5 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Ring R] (r : R → R → Prop) (a : RingQuot r), -a + a = 0 | false |
IsDedekindDomain.HeightOneSpectrum.valuation_of_unit_eq | Mathlib.RingTheory.DedekindDomain.SelmerGroup | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type v} [inst_2 : Field K] [inst_3 : Algebra R K]
[inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (x : Rˣ),
v.valuationOfNeZero ((Units.map ↑(algebraMap R K)) x) = 1 | true |
Lean.Parser.Syntax.paren | Lean.Parser.Syntax | Lean.Parser.Parser | true |
instIsEquivalenceFGModuleCatUlift | Mathlib.Algebra.Category.FGModuleCat.EssentiallySmall | ∀ (R : Type u) [inst : CommRing R], (FGModuleCat.ulift R).IsEquivalence | true |
CategoryTheory.Limits.instEpiπ | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{β : Type w} [inst_2 : DecidableEq β] (f : β → C) [inst_3 : CategoryTheory.Limits.HasCoproduct f] (b : β),
CategoryTheory.Epi (CategoryTheory.Limits.Sigma.π f b) | true |
AlgHom.ulift_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Semiring T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] (f : S →ₐ[R] T) (x : ULift.{u_4, u_2} S),
(AlgHom.ulift.{u_4, u_6, u_5, u_1, u_2, u_3} f) x = { down := f x.down } | true |
Lean.Lsp.LeanIdentifier.ctorIdx | Lean.Data.Lsp.Internal | Lean.Lsp.LeanIdentifier → ℕ | false |
Set.vadd_set_symmDiff | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {s t : Set β} {a : α},
a +ᵥ symmDiff s t = symmDiff (a +ᵥ s) (a +ᵥ t) | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.AntitoneOn.sum_le_integral._simp_1_2 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | false |
Matrix.submatrix_mem_matrix | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} {S : Set α} {M : Matrix m n α} {r : l → m}
{c : o → n}, M ∈ S.matrix → M.submatrix r c ∈ S.matrix | true |
Std.Slice.Internal.SubarrayData.casesOn | Init.Data.Array.Subarray | {α : Type u} →
{motive : Std.Slice.Internal.SubarrayData α → Sort u_1} →
(t : Std.Slice.Internal.SubarrayData α) →
((array : Array α) →
(start stop : ℕ) →
(start_le_stop : start ≤ stop) →
(stop_le_array_size : stop ≤ array.size) →
motive
... | false |
Algebra.GrothendieckGroup.eq_1 | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | ∀ (M : Type u_1) [inst : CommMonoid M], Algebra.GrothendieckGroup M = Localization ⊤ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_minKeyD._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
SubMulAction.subset_coe_one | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : One M], 1 ⊆ ↑1 | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Degenerate.0.SSet.nonDegenerate_iff_of_isIso._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Degenerate | ∀ {X Y : SSet} (f : X ⟶ Y) [CategoryTheory.IsIso f] {n : ℕ} (x : X.obj (Opposite.op (SimplexCategory.mk n))),
(f.app (Opposite.op (SimplexCategory.mk n)) x ∈ Y.degenerate n) = (x ∈ X.degenerate n) | false |
instTopologicalSpaceWeakDual._proof_3 | Mathlib.Topology.Algebra.Module.WeakDual | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
instTopologicalSpaceWeakDual._aux_1 𝕜 E Set.univ | false |
Equiv.nonUnitalRing._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalRing β] (x y : α), e (e.symm (e x * e y)) = e x * e y | false |
ConditionallyCompleteLinearOrderedField.inducedMap_nonneg | Mathlib.Algebra.Order.CompleteField | ∀ {α : Type u_2} {β : Type u_3} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Field β]
[inst_4 : ConditionallyCompleteLinearOrder β] [IsStrictOrderedRing β] [Archimedean α] {a : α},
0 ≤ a → 0 ≤ ConditionallyCompleteLinearOrderedField.inducedMap α β a | true |
CategoryTheory.Triangulated.AbelianSubcategory.isLimitKernelForkOfDistTriang._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_2} {A : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | false |
Algebra.TensorProduct.instNonUnitalNonAssocRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocRing A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalNonAssocSemiring B] →
[inst_... | true |
MeasureTheory.lintegral_smul_measure | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {R : Type u_4} [inst : SMul R ENNReal]
[inst_1 : IsScalarTower R ENNReal ENNReal] (c : R) (f : α → ENNReal), ∫⁻ (a : α), f a ∂c • μ = c • ∫⁻ (a : α), f a ∂μ | true |
Lean.Elab.ExpandDeclIdResult.noConfusion | Lean.Elab.DeclModifiers | {P : Sort u} → {t t' : Lean.Elab.ExpandDeclIdResult} → t = t' → Lean.Elab.ExpandDeclIdResult.noConfusionType P t t' | false |
Lean.Lsp.LeanFileProgressKind.processing.elim | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanFileProgressKind → Sort u} →
(t : Lean.Lsp.LeanFileProgressKind) → t.ctorIdx = 0 → motive Lean.Lsp.LeanFileProgressKind.processing → motive t | false |
Lean.Meta.Tactic.Backtrack.backtrack | Lean.Meta.Tactic.Backtrack | optParam Lean.Meta.Tactic.Backtrack.BacktrackConfig { } →
optParam Lean.Name Lean.Name.anonymous →
(Lean.MVarId → Lean.MetaM (Lean.Meta.Iterator (List Lean.MVarId))) →
List Lean.MVarId → Lean.MetaM (List Lean.MVarId) | true |
Orientation.map_symm | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
(ι : Type u_4) (e : M ≃ₗ[R] N), (Orientation.map ι e).symm = Orientation.map ι e.symm | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls._sparseCasesOn_1 | Lean.Elab.MutualInductive | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Turing.PartrecToTM2.natEnd.match_1 | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.PartrecToTM2.Γ' → Sort u_1) →
(x : Turing.PartrecToTM2.Γ') →
(Unit → motive Turing.PartrecToTM2.Γ'.consₗ) →
(Unit → motive Turing.PartrecToTM2.Γ'.cons) → ((x : Turing.PartrecToTM2.Γ') → motive x) → motive x | false |
List.Duplicate.duplicate_cons | Mathlib.Data.List.Duplicate | ∀ {α : Type u_1} {l : List α} {x : α}, List.Duplicate x l → ∀ (y : α), List.Duplicate x (y :: l) | true |
Lean.Compiler.LCNF.eraseCode | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.CompilerM Unit | true |
ProbabilityTheory.Kernel.densityProcess_fst_univ | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)}
[ProbabilityTheory.IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ),
κ.densityProcess κ.fst n a x Set.univ = if ... | true |
Std.DTreeMap.Internal.Impl.toList_insert!_perm | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : BEq α] [Std.TransOrd α]
[Std.LawfulBEqOrd α],
t.WF →
∀ {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insert! k v t).toList.Perm
(⟨k, v⟩ :: List.filter (fun x => decide ¬(k == x.fst) = true) t.toList) | true |
_private.Mathlib.Algebra.Homology.Embedding.TruncLE.0.HomologicalComplex.instIsStrictlySupportedTruncLE_1._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_5} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_4}
[inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncLE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | false |
Std.ExtDTreeMap.minKey?_erase_eq_of_not_compare_eq_minKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (∀ {km : α}, t.minKey? = some km → ¬cmp k km = Ordering.eq) → (t.erase k).minKey? = t.minKey? | true |
Ordinal.enumOrd_mem | Mathlib.SetTheory.Ordinal.Enum | ∀ {s : Set Ordinal.{u}}, ¬BddAbove s → ∀ (o : Ordinal.{u}), Ordinal.enumOrd s o ∈ s | true |
Monoid.Foldr | Mathlib.Control.Fold | Type u → Type u | true |
_private.Lean.Server.Rpc.Deriving.0.Lean.Server.RpcEncodable.deriveInstance.match_1 | Lean.Server.Rpc.Deriving | (motive : Array Lean.Name → Sort u_1) →
(declNames : Array Lean.Name) →
((typeName : Lean.Name) → motive #[typeName]) → ((x : Array Lean.Name) → motive x) → motive declNames | false |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_19 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam
(∀ (a : WittVector.StandardOneDimIsocrystal p k _m),
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_17 p k _m 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | false |
CategoryTheory.nerve.functorOfNerveMap | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | {C D : Type u} →
[inst : CategoryTheory.SmallCategory C] →
[inst_1 : CategoryTheory.SmallCategory D] →
(CategoryTheory.Nerve.nerveFunctor₂.obj (CategoryTheory.Cat.of C) ⟶
CategoryTheory.Nerve.nerveFunctor₂.obj (CategoryTheory.Cat.of D)) →
CategoryTheory.Functor C D | true |
PosNum.lt_to_nat | Mathlib.Data.Num.Lemmas | ∀ {m n : PosNum}, ↑m < ↑n ↔ m < n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.