name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
uniqueMDiffWithinAt_iff_uniqueDiffWithinAt | Mathlib.Geometry.Manifold.MFDeriv.FDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {x : E},
UniqueMDiffWithinAt (modelWithCornersSelf 𝕜 E) s x ↔ UniqueDiffWithinAt 𝕜 s x |
Topology.WithLawson.isOpen_preimage_ofLawson | Mathlib.Topology.Order.LawsonTopology | ∀ {α : Type u_1} [inst : Preorder α] {S : Set α},
IsOpen (⇑Topology.WithLawson.ofLawson ⁻¹' S) ↔ TopologicalSpace.IsOpen S |
«term{}» | Init.Core | Lean.ParserDescr |
Lean.Meta.Match.mkAppDiscrEqs | Lean.Meta.Match.MatchEqs | Lean.Expr → Array Lean.Expr → ℕ → Lean.MetaM Lean.Expr |
Std.Packages.LinearPreorderOfLEArgs._proof_5 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (le : LE α), (∀ (a b : α), a ≤ b ∨ b ≤ a) → ∀ (a : α), a ≤ a |
_private.Lean.Compiler.LCNF.SplitSCC.0.Lean.Compiler.LCNF.SplitScc.findSccCalls.goCode.match_1 | Lean.Compiler.LCNF.SplitSCC | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(x : Lean.Compiler.LCNF.LetValue pu) →
((name : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.pure) Lean.Compiler.LCNF.LetValue._auto_3) →
motive (Lean.Compiler.LCNF.LetValue.const name us args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_13) →
motive (Lean.Compiler.LCNF.LetValue.fap name args h)) →
((name : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15) →
motive (Lean.Compiler.LCNF.LetValue.pap name args h)) →
((x : Lean.Compiler.LCNF.LetValue pu) → motive x) → motive x |
Polynomial.derivation_ext | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] {D₁ D₂ : Derivation R (Polynomial R) A},
D₁ Polynomial.X = D₂ Polynomial.X → D₁ = D₂ |
WType.Listα.nil.elim | Mathlib.Data.W.Constructions | {γ : Type u} →
{motive : WType.Listα γ → Sort u_1} → (t : WType.Listα γ) → t.ctorIdx = 0 → motive WType.Listα.nil → motive t |
SSet.Truncated.Edge.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge._proof_1 })} →
{motive : SSet.Truncated.Edge x₀ x₁ → Sort u_1} →
((edge : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.Edge._proof_2 })) →
(src_eq :
X.map (SimplexCategory.Truncated.δ₂ 1 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op edge =
x₀) →
(tgt_eq :
X.map (SimplexCategory.Truncated.δ₂ 0 SSet.Truncated.Edge._proof_1 SSet.Truncated.Edge._proof_3).op
edge =
x₁) →
motive { edge := edge, src_eq := src_eq, tgt_eq := tgt_eq }) →
(t : SSet.Truncated.Edge x₀ x₁) → motive t |
AbsoluteValue.LiesOver.casesOn | Mathlib.Analysis.Normed.Ring.WithAbs | {K : Type u_3} →
{L : Type u_4} →
{S : Type u_5} →
[inst : CommRing K] →
[inst_1 : IsSimpleRing K] →
[inst_2 : CommRing L] →
[inst_3 : Algebra K L] →
[inst_4 : PartialOrder S] →
[inst_5 : Nontrivial L] →
[inst_6 : Semiring S] →
{w : AbsoluteValue L S} →
{v : AbsoluteValue K S} →
{motive : w.LiesOver v → Sort u} →
(t : w.LiesOver v) → ((comp_eq' : w.comp ⋯ = v) → motive ⋯) → motive t |
differentiableAt_const._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {x : E} (c : F), DifferentiableAt 𝕜 (fun x => c) x = True |
AddSemigrp.hom_comp | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y T : AddSemigrp} (f : X ⟶ Y) (g : Y ⟶ T),
AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (AddSemigrp.Hom.hom g).comp (AddSemigrp.Hom.hom f) |
UInt8.reduceBinPred._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Name → ℕ → (UInt8 → UInt8 → Bool) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.Step |
Matrix.IsDiag.submatrix | Mathlib.LinearAlgebra.Matrix.IsDiag | ∀ {α : Type u_1} {n : Type u_4} {m : Type u_5} [inst : Zero α] {A : Matrix n n α},
A.IsDiag → ∀ {f : m → n}, Function.Injective f → (A.submatrix f f).IsDiag |
PMF.toMeasure_inj._simp_1 | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {p q : PMF α},
(p.toMeasure = q.toMeasure) = (p = q) |
ProbabilityTheory.Kernel.rnDeriv_pos | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[ProbabilityTheory.IsFiniteKernel η] {a : α}, (κ a).AbsolutelyContinuous (η a) → ∀ᵐ (x : γ) ∂κ a, 0 < κ.rnDeriv η a x |
ProbabilityTheory.gaussianPDF | Mathlib.Probability.Distributions.Gaussian.Real | ℝ → NNReal → ℝ → ENNReal |
Pi.nonUnitalNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalNormedRing (R i)]
{x y : (i : ι) → R i}, dist x y = 0 → x = y |
FirstOrder.Language.BoundedFormula.equal.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 1 →
({n : ℕ} → (t₁ t₂ : L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.equal t₁ t₂)) →
motive a t |
instAddInt64 | Init.Data.SInt.Basic | Add Int64 |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Search.0.Lean.Meta.Grind.Arith.Linear.findInt?.go | Lean.Meta.Tactic.Grind.Arith.Linear.Search | Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℤ → ℤ → Option ℚ |
EMetric.diam_one | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : One X], Metric.ediam 1 = 0 |
ProbabilityTheory.integrable_rpow_abs_of_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
0 ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => |X ω| ^ p) μ |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.solveSomeLocalFVarIdCnstr?.go._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Alt →
List (Lean.Expr × Lean.Expr) → Lean.MetaM (Option (Lean.FVarId × Lean.Expr) × List (Lean.Expr × Lean.Expr)) |
CategoryTheory.mop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).mop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.mop { unmop := X } |
Std.Internal.UV.Signal.cancel | Std.Internal.UV.Signal | Std.Internal.UV.Signal → IO Unit |
MvPolynomial.pderiv._proof_1 | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R], IsScalarTower R (MvPolynomial σ R) (MvPolynomial σ R) |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.evalTactic.match_9 | Lean.Elab.Tactic.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive ex |
List.zipWith_eq_nil_iff | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {l : List α} {l' : List β},
List.zipWith f l l' = [] ↔ l = [] ∨ l' = [] |
CategoryTheory.Limits.widePushoutShapeOp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type w) →
CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ |
Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.217797861._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO
(Lean.PersistentEnvExtension Lean.Name (Lean.Name × Lean.Linter.IgnoreFunction)
(List Lean.Name × Array Lean.Linter.IgnoreFunction)) |
PresheafOfModules.presheaf._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (X : Cᵒᵖ),
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.CategoryStruct.id X))) ⋯) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X)) |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.initializeState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.StructInstM✝ Unit |
CompletelyDistribLattice.MinimalAxioms.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(toCompleteLattice : CompleteLattice α) →
(∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice.MinimalAxioms α |
Lean.instForInMVarIdSetMVarIdOfMonad | Lean.Expr | {m : Type u_1 → Type u_2} → [Monad m] → ForIn m Lean.MVarIdSet Lean.MVarId |
_private.Mathlib.Order.Sublocale.0.Sublocale.giAux._proof_3 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : ↥S), x ≤ Sublocale.restrictAux✝ S ↑x |
CategoryTheory.Functor.map_braiding_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_6 : F.Braided] {Z : D}
(h : F.obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y X) ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (β_ X Y).hom) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.OplaxMonoidal.δ F X Y)
(CategoryTheory.CategoryStruct.comp (β_ (F.obj X) (F.obj Y)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F Y X) h)) |
Lean.Parser.anyOfFn._unsafe_rec | Lean.Parser.Basic | List Lean.Parser.Parser → Lean.Parser.ParserFn |
Subring.range_snd | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S], (RingHom.snd R S).rangeS = ⊤ |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.loop | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array Lean.Expr →
List Lean.FVarId →
Lean.Expr →
ℕ → ℕ → List Lean.Meta.RefinedDiscrTree.StackEntry → Lean.MetaM (List Lean.Meta.RefinedDiscrTree.StackEntry) |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_filter_eq_false_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {f : α → β → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter f m)).isEmpty = false ↔
∃ k, ∃ (h : m.contains k = true), f (m.getKey k h) (Std.DHashMap.Internal.Raw₀.Const.get m k h) = true) |
Dyadic.toRat_le_toRat_iff._simp_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.toRat ≤ y.toRat) = (x ≤ y) |
MeasureTheory.Measure.pi_noAtoms | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (i : ι)
[MeasureTheory.NoAtoms (μ i)], MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ) |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | (B : Type u₁) →
[inst : CategoryTheory.Bicategory B] →
(C : Type u₂) → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.Bicategory (CategoryTheory.OplaxFunctor B C) |
OrderDual.instModule' | Mathlib.Algebra.Order.Module.Synonym | {α : Type u_1} → {β : Type u_2} → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α βᵒᵈ |
CStarMatrix.instAddCommGroupWithOne._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_2} {A : Type u_1} [inst : DecidableEq n] [inst_1 : AddCommGroupWithOne A], ↑0 = 0 |
CategoryTheory.ShortComplex.Splitting.unop_r | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.Splitting), h.unop.r = h.s.unop |
Std.ExtTreeMap.maxKey?_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {km : α},
t.maxKey? = some km → km ∈ t |
Lean.Server.Watchdog.WorkerEvent.crashed.injEq | Lean.Server.Watchdog | ∀ (exitCode exitCode_1 : UInt32),
(Lean.Server.Watchdog.WorkerEvent.crashed exitCode = Lean.Server.Watchdog.WorkerEvent.crashed exitCode_1) =
(exitCode = exitCode_1) |
Lean.Doc.Syntax.metadataContents | Lean.DocString.Syntax | Lean.Parser.Parser |
Monoid.exponent_multiplicative | Mathlib.GroupTheory.Exponent | ∀ {G : Type u_1} [inst : AddMonoid G], Monoid.exponent (Multiplicative G) = AddMonoid.exponent G |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atTop_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g |
Array.forall_mem_ne' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (∀ a' ∈ xs, ¬a' = a) ↔ a ∉ xs |
Real.RingHom.unique._proof_2 | Mathlib.Data.Real.CompleteField | ∀ (f : ℝ →+* ℝ), { toRingHom := f, monotone' := ⋯ }.toRingHom = default.toRingHom |
Std.HashMap.keys | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List α |
Std.Net.IPAddr.family.match_1 | Std.Net.Addr | (motive : Std.Net.IPAddr → Sort u_1) →
(x : Std.Net.IPAddr) →
((addr : Std.Net.IPv4Addr) → motive (Std.Net.IPAddr.v4 addr)) →
((addr : Std.Net.IPv6Addr) → motive (Std.Net.IPAddr.v6 addr)) → motive x |
BitVec.reduceGE._regBuiltin.BitVec.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.776923109._hygCtx._hyg.25 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
DirichletCharacter.convolution_twist_vonMangoldt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N),
(LSeries.convolution ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) fun n => χ ↑n) =
(fun n => χ ↑n) * fun n => Complex.log ↑n |
Lean.Language.Lean.HeaderParsedSnapshot.mk | Lean.Language.Lean.Types | Lean.Language.Snapshot →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Lean.Parser.InputContext →
Lean.Syntax → Option Lean.Language.Lean.HeaderParsedState → Lean.Language.Lean.HeaderParsedSnapshot |
LocallyFinite.Realizer.recOn | Mathlib.Data.Analysis.Topology | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
{F : Ctop.Realizer α} →
{f : β → Set α} →
{motive : LocallyFinite.Realizer F f → Sort u} →
(t : LocallyFinite.Realizer F f) →
((bas : (a : α) → { s // a ∈ F.F.f s }) →
(sets : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas x)).Nonempty}) →
motive { bas := bas, sets := sets }) →
motive t |
AlgebraicGeometry.structurePresheafInModuleCat | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [Module R M] → TopCat.Presheaf (ModuleCat R) (AlgebraicGeometry.PrimeSpectrum.Top R) |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'.match_1_11 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : StarMul R] [inst_2 : CommRing S] [inst_3 : Algebra S R]
(u v : ↥(unitary R)) (motive : (∃ y, y • 1 = star ↑v * ↑u) → Prop) (x : ∃ y, y • 1 = star ↑v * ↑u),
(∀ (y : S) (h : y • 1 = star ↑v * ↑u), motive ⋯) → motive x |
Lean.Parser.Term.inaccessible._regBuiltin.Lean.Parser.Term.inaccessible_1 | Lean.Parser.Term | IO Unit |
Monoid.CoprodI.Word.equivPair._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] (i : ι) (w : Monoid.CoprodI.Word M),
Monoid.CoprodI.Word.rcons ↑(Monoid.CoprodI.Word.equivPairAux✝ i w) = w |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.iteratedDerivWithin_tsum_exp_aux_eq._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) |
Configuration.Nondegenerate.exists_line | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.Nondegenerate P L] (p : P), ∃ l, p ∉ l |
Nat.EqResult.eq.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (x y p x_1 y_1 p_1 : Lean.Expr), (Nat.EqResult.eq x y p = Nat.EqResult.eq x_1 y_1 p_1) = (x = x_1 ∧ y = y_1 ∧ p = p_1) |
ContMDiffMap.restrictMonoidHom._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_3}
[inst_5 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {H' : Type u_6} [inst_6 : TopologicalSpace H']
(I' : ModelWithCorners 𝕜 E' H') {N : Type u_4} [inst_7 : TopologicalSpace N] [inst_8 : ChartedSpace H N]
{n : WithTop ℕ∞} (G : Type u_7) [inst_9 : TopologicalSpace G] [inst_10 : ChartedSpace H' G]
{U V : TopologicalSpace.Opens N} (h : U ≤ V) (f : ContMDiffMap I I' (↥V) G n), ContMDiff I I' n (⇑f ∘ Set.inclusion h) |
mellinConvergent_of_isBigO_rpow_exp | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ},
0 < a →
∀ {f : ℝ → E} {s : ℂ},
MeasureTheory.LocallyIntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(f =O[Filter.atTop] fun t => Real.exp (-a * t)) →
(f =O[nhdsWithin 0 (Set.Ioi 0)] fun x => x ^ (-b)) → b < s.re → MellinConvergent f s |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.w_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution hζ),
S.c = (hζ.toInteger - 1) ^ S.multiplicity * FermatLastTheoremForThreeGen.Solution.w✝ S |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.Consumer.ctorIdx | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded.Consumer✝ α → ℕ |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.casesExpand.match_19 | Batteries.CodeAction.Misc | (motive : Option (Array (Lean.Name × Array Lean.Name)) → Sort u_1) →
(__discr : Option (Array (Lean.Name × Array Lean.Name))) →
((ctors : Array (Lean.Name × Array Lean.Name)) → motive (some ctors)) →
((x : Option (Array (Lean.Name × Array Lean.Name))) → motive x) → motive __discr |
AddAction.stabilizerEquivStabilizer_trans | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a),
k = h + g →
(AddAction.stabilizerEquivStabilizer hg).trans (AddAction.stabilizerEquivStabilizer hh) =
AddAction.stabilizerEquivStabilizer hk |
Lean.Meta.Grind.SymbolPriorityEntry.mk.noConfusion | Lean.Meta.Tactic.Grind.EMatchTheorem | {P : Sort u} →
{declName : Lean.Name} →
{prio : ℕ} →
{declName' : Lean.Name} →
{prio' : ℕ} →
{ declName := declName, prio := prio } = { declName := declName', prio := prio' } →
(declName = declName' → prio = prio' → P) → P |
BoundedOrderHomClass.toBotHomClass | Mathlib.Order.Hom.Bounded | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : LE α] [inst_2 : LE β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedOrderHomClass F α β], BotHomClass F α β |
_private.Mathlib.Topology.UniformSpace.Defs.0.UniformSpace.hasBasis_nhds._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) |
Std.Iterators.Types.Zip.instFinite₂ | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type w → Type w'} {α₁ β₁ : Type w} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type w} [inst_1 : Std.Iterator α₂ m β₂]
[inst_2 : Monad m] [Std.Iterators.Productive α₁ m] [Std.Iterators.Finite α₂ m],
Std.Iterators.Finite (Std.Iterators.Types.Zip α₁ m α₂ β₂) m |
Std.TransCmp.lt_of_eq_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.lt → cmp a c = Ordering.lt |
List.insert_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, a ∉ l → List.insert a l = a :: l |
Real.denselyNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (x x_1 : ℝ), 0 ≤ x → x < x_1 → ∃ a, x < ‖a‖ ∧ ‖a‖ < x_1 |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.at_least_as_long_as_coind._simp_1_8 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α), (s = Stream'.Seq.nil) = (s.length' = 0) |
StrictMonoOn.mapsTo_Ioc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : PartialOrder α] [inst_1 : Preorder β] {a b : α},
StrictMonoOn f (Set.Icc a b) → Set.MapsTo f (Set.Ioc a b) (Set.Ioc (f a) (f b)) |
_private.Init.Data.String.Iterate.0.String.Slice.ByteIterator.finitenessRelation._proof_2 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1},
WellFounded
(InvImage WellFoundedRelation.rel fun it => it.internalState.s.utf8ByteSize - it.internalState.offset.byteIdx) |
Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKeyD k fallback = fallback |
AddSubgroup.card_dvd_of_injective | Mathlib.GroupTheory.Coset.Card | ∀ {α : Type u_1} [inst : AddGroup α] {H : Type u_2} [inst_1 : AddGroup H] (f : α →+ H),
Function.Injective ⇑f → Nat.card α ∣ Nat.card H |
OrderHom.apply | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → α → (α →o β) →o β |
Manifold.«_aux_Mathlib_Geometry_Manifold_Instances_Real___macroRules_Manifold_term𝓡∂__1» | Mathlib.Geometry.Manifold.Instances.Real | Lean.Macro |
CompleteDistribLattice.toHNot | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → HNot α |
MeasurableEquiv.piFinSuccAbove_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_8) [inst : (i : Fin (n + 1)) → MeasurableSpace (α i)] (i : Fin (n + 1)),
⇑(MeasurableEquiv.piFinSuccAbove α i) = ⇑(Fin.insertNthEquiv α i).symm |
LieAlgebra.radical_eq_top_of_isSolvable | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.IsSolvable L], LieAlgebra.radical R L = ⊤ |
String.all_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.all s p = true ↔ ∀ c ∈ s.toList, p c = true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_lt._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool} {s : ℕ},
i < (List.findIdxs p xs s).length → 0 < (List.findIdxs p xs s).length |
Substring.Raw.toString | Init.Data.String.Substring | Substring.Raw → String |
Lean.Parser.antiquotExpr | Lean.Parser.Basic | Lean.Parser.Parser |
ZFSet.vonNeumann_subset_vonNeumann_iff | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, ZFSet.vonNeumann a ⊆ ZFSet.vonNeumann b ↔ a ≤ b |
Finpartition.ofSubset._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {parts : Finset α},
parts ⊆ P.parts → ⊥ ∈ parts → False |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_union._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] {v : V} {s : Set P},
(v ∈ asymptoticCone k s) = ∃ᶠ (p : P) in AffineSpace.asymptoticNhds k P v, p ∈ s |
Finsupp.instNonUnitalRing._proof_4 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂ |
KaehlerDifferential.map_D | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
(B : Type u_3) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra A B]
[inst_7 : Algebra S B] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B]
[inst_11 : SMulCommClass S A B] (x : A),
(KaehlerDifferential.map R S A B) ((KaehlerDifferential.D R A) x) = (KaehlerDifferential.D S B) ((algebraMap A B) x) |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.Module.Basis.parallelepiped._simp_5 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ (α : Sort u), (∀ (a : α), True) = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.