name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CommRingCat.commRingObj._aux_1 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) → (j : J) → CommRing ((F.comp (CategoryTheory.forget CommRingCat)).obj j) | false |
AddMonoidAlgebra.uniqueAlgEquiv | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
{A : Type u_4} →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] → [inst_3 : AddMonoid M] → [Unique M] → AddMonoidAlgebra A M ≃ₐ[R] A | true |
TestFunction.instAddCommGroup._proof_8 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞},
autoParam (∀ (n_1 : ℕ) (a : TestFunction Ω F n), ↑n_1.succ • a = ↑n_1 • a + a) SubNegMonoid.zsmul_succ'._autoParam | false |
Homeomorph.preimageImageRestrict._proof_2 | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} (α : ι → Type u_2) (S : Set ι) (s : Set ((j : ι) → α j)) (p : ↑(Sᶜ.restrict '' s) × ((i : ↑S) → α ↑i)),
(fun x => (⟨Sᶜ.restrict ↑x, ⋯⟩, fun i => ↑x ↑i)) ((fun p => ⟨Topology.reorderRestrictProd S s p, ⋯⟩) p) = p | false |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_counitIso_hom_app_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(X :
CategoryTheory.Comma (CategoryTheory.Functor.const SimplexCategory)
(CategoryTheory.Functor.id (CategoryTheory.Functor SimplexCategory C))),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.counitIso.hom.app X).left =
Catego... | true |
UV.shadow_compression_subset_compression_shadow | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} (u v : Finset α),
(∀ x ∈ u, ∃ y ∈ v, UV.IsCompressed (u.erase x) (v.erase y) 𝒜) →
(UV.compression u v 𝒜).shadow ⊆ UV.compression u v 𝒜.shadow | true |
Lean.initFn._@.Lean.Util.SafeExponentiation.3025597618._hygCtx._hyg.4 | Lean.Util.SafeExponentiation | IO (Lean.Option ℕ) | false |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulStrictMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True | false |
CategoryTheory.leftDistributor_ext_left | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y : C} {f : J → C}
{g h : CategoryTheo... | true |
Submodule.submoduleOf_sup_of_le | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N₁ N₂ N : Submodule R M}, N₁ ≤ N → N₂ ≤ N → (N₁ ⊔ N₂).submoduleOf N = N₁.submoduleOf N ⊔ N₂.submoduleOf N | true |
Lean.Elab.Tactic.evalSimpArithBang._regBuiltin.Lean.Elab.Tactic.evalSimpArithBang_1 | Lean.Elab.Tactic.SimpArith | IO Unit | false |
_private.Lean.Environment.0.Lean.ImportedModule.rec | Lean.Environment | {motive : Lean.ImportedModule✝ → Sort u} →
((toEffectiveImport : Lean.EffectiveImport) →
(parts : Array (Lean.ModuleData × Lean.CompactedRegion)) →
(irData? : Option (Lean.ModuleData × Lean.CompactedRegion)) →
(needsData needsIRTrans : Bool) →
motive
{ toEffectiveImpo... | false |
LinearEquiv.toEquiv | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
... | true |
CategoryTheory.Grothendieck.fiber_eqToHom | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (h : X = Y), (CategoryTheory.eqToHom h).fiber = CategoryTheory.eqToHom ⋯ | true |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.comap_dist_right_atTop._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | false |
Stream'.get_even | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (s : Stream' α), s.even.get n = s.get (2 * n) | true |
List.bagInter.match_1.congr_eq_3 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (x x_1 : List α) (h_1 : (x : List α) → motive [] x)
(h_2 : (x : List α) → motive x []) (h_3 : (a : α) → (l₁ l₂ : List α) → motive (a :: l₁) l₂) (a : α) (l₁ l₂ : List α),
x = a :: l₁ →
x_1 = l₂ →
(l₂ = [] → False) →
(match x, x_1 with
... | true |
rothNumberNat_le_ruzsaSzemerediNumberNat' | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ (n : ℕ), (↑n / 3 - 2) * ↑(rothNumberNat ((n - 3) / 6)) ≤ ↑(ruzsaSzemerediNumberNat n) | true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral.0.integral_gaussian_complex._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | Complex.ofReal = ⇑(algebraMap ℝ ℂ) | false |
mem_subalgebraOfSubring._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] {x : R} {S : Subring R}, (x ∈ subalgebraOfSubring S) = (x ∈ S) | false |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlock.withSpace | Lean.Elab.DocString | String → String | true |
Setoid.instPartialOrder | Mathlib.Data.Setoid.Basic | {α : Type u_1} → PartialOrder (Setoid α) | true |
AlgHom.toLieHom_apply | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {R : Type u} [inst_1 : CommRing R] [inst_2 : Algebra R A] {B : Type w} [inst_3 : Ring B]
[inst_4 : Algebra R B] (f : A →ₐ[R] B) (x : A), f.toLieHom x = f x | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.extractBind.match_4 | Lean.Elab.Do.Legacy | (motive : Option Lean.Expr → Sort u_1) →
(expectedType? : Option Lean.Expr) →
((expectedType : Lean.Expr) → motive (some expectedType)) →
((x : Option Lean.Expr) → motive x) → motive expectedType? | false |
MeasureTheory.IsStoppingTime | Mathlib.Probability.Process.Stopping | {Ω : Type u_1} →
{ι : Type u_3} → {m : MeasurableSpace Ω} → [inst : Preorder ι] → MeasureTheory.Filtration ι m → (Ω → WithTop ι) → Prop | true |
Derivation.map_smul_of_tower | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {S : Type u_5}
[inst_6 : SMul S A] [inst_7 : SMul S M] [LinearMap.CompatibleSMul A M S R] (D : Derivation R A M) (r : S) (a :... | true |
List.Perm.trans | Init.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ l₃ : List α}, l₁.Perm l₂ → l₂.Perm l₃ → l₁.Perm l₃ | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.exp_inj._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, (a ≡ b [PMOD p]) = ∃ m, b - a = m • p | false |
LaurentPolynomial.isLocalization | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R], IsLocalization.Away Polynomial.X (LaurentPolynomial R) | true |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Quaternion.instGroupWithZero._proof_7 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R], Nontrivial (Quaternion R) | false |
SimpleGraph.diam_anti_of_ediam_ne_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G G' : SimpleGraph α}, G ≤ G' → G.ediam ≠ ⊤ → G'.diam ≤ G.diam | true |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.initFn._@.Lean.Parser.Term.Basic.2382944618._hygCtx._hyg.2 | Lean.Parser.Term.Basic | IO Unit | false |
Isometry.mapsTo_emetric_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ENNReal), Set.MapsTo f (Metric.closedEBall x r) (Metric.closedEBall (f x) r) | true |
Std.HashMap.Raw.emptyWithCapacity | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → optParam ℕ 8 → Std.HashMap.Raw α β | true |
SheafOfModules.Presentation.IsFinite.casesOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : J.HasShe... | false |
Lean.Elab.Term.Do.ToTerm.Kind.nestedSBC | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite._sparseCasesOn_1 | Mathlib.Tactic.GRewrite.Core | {motive : ℕ → Sort u} → (t : ℕ) → ((n : ℕ) → motive n.succ) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.reverse._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.reverse.support.tail.Nodup = p.support.tail.Nodup | false |
Lean.Server.Watchdog.ServerRequestData.freshServerRequestID | Lean.Server.Watchdog | Lean.Server.Watchdog.ServerRequestData → ℕ | true |
Ring.inverse_non_unit | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), ¬IsUnit x → Ring.inverse x = 0 | true |
HasDerivAt.nonpos_of_antitone | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[OrderTopology 𝕜] {g : 𝕜 → 𝕜} {g' : 𝕜}, HasDerivAt g g' x → Antitone g → g' ≤ 0 | true |
Module.Basis.addSubgroupOfClosure._proof_1 | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {M : Type u_1} {R : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (A : AddSubgroup M)
{ι : Type u_2} (b : Module.Basis ι R M),
A = AddSubgroup.closure (Set.range ⇑b) → Submodule.span ℤ (Set.range ⇑b) = AddSubgroup.toIntSubmodule A | false |
CategoryTheory.Limits.PushoutCocone.ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : X ⟶ Y} →
{g : X ⟶ Z} →
{s t : CategoryTheory.Limits.PushoutCocone f g} →
(i : s.pt ≅ t.pt) →
autoParam (CategoryTheory.CategoryStruct.comp s.inl i.hom = t.inl)
Category... | true |
ProbabilityTheory.Kernel.condKernelReal.eq_1 | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {γ : Type u_3} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × ℝ))
[inst_1 : ProbabilityTheory.IsFiniteKernel κ],
κ.condKernelReal = ProbabilityTheory.IsCondKernelCDF.toKernel κ.condKernelCDF ⋯ | true |
Nonempty.some | Mathlib.Logic.Nonempty | {α : Sort u_3} → Nonempty α → α | true |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.map_add_atTop_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a ≤ c - b) = (a + b ≤ c) | false |
Lagrange.eval_basis_of_ne | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F} {i j : ι},
i ≠ j → j ∈ s → Polynomial.eval (v j) (Lagrange.basis s v i) = 0 | true |
Lean.registerOption | Lean.Data.Options | Lean.Name → Lean.OptionDecl → IO Unit | true |
TensorProduct.norm_map | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
[inst_4 : InnerProductSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G]
[inst_7 : NormedAdd... | true |
Finsupp.sum_ite_eq | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : DecidableEq α]
(f : α →₀ M) (a : α) (b : α → M → N),
(f.sum fun x v => if a = x then b x v else 0) = if a ∈ f.support then b a (f a) else 0 | true |
Lean.PersistentHashMap.mk.injEq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (root root_1 : Lean.PersistentHashMap.Node α β),
({ root := root } = { root := root_1 }) = (root = root_1) | true |
Lean.ExternEntry.inline.noConfusion | Lean.Compiler.ExternAttr | {P : Sort u} →
{backend : Lean.Name} →
{pattern : String} →
{backend' : Lean.Name} →
{pattern' : String} →
Lean.ExternEntry.inline backend pattern = Lean.ExternEntry.inline backend' pattern' →
(backend = backend' → pattern = pattern' → P) → P | false |
FirstOrder.Language.Term.inhabitedOfConstant | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [Inhabited L.Constants] → Inhabited (L.Term α) | true |
Mathlib.Tactic.Order.AtomicFact.le.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.le lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof | true |
OrderDual.instSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : Semigroup α] → Semigroup αᵒᵈ | true |
EReal.instInv | Mathlib.Data.EReal.Inv | Inv EReal | true |
RegularSpace.inf | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_3} {t₁ t₂ : TopologicalSpace X}, RegularSpace X → RegularSpace X → RegularSpace X | true |
Fin.reduceBin | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Lean.Name → ℕ → ({n : ℕ} → Fin n → Fin n → Fin n) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | true |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
FirstOrder.Language.IsOrdered.recOn | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{motive : L.IsOrdered → Sort u_1} →
(t : L.IsOrdered) → ((leSymb : L.Relations 2) → motive { leSymb := leSymb }) → motive t | false |
DomAddAct.mk_vadd_indicatorConstLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : VAdd M α]
[MeasureTheory.VAddInvariantMeasure M α μ] (c : M) {s : Set α},
MeasurableSet s → μ s ≠ ⊤ → μ ((fun x => c +ᵥ x) ⁻¹' s) ≠ ⊤ | false |
HasEnoughRootsOfUnity.finite_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Finite ↥(rootsOfUnity n M) | true |
_private.Mathlib.Order.Filter.Map.0.Filter.mem_comap_prodMk._simp_1_5 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
Submodule.spanRank_finite_iff_fg._simp_1 | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M},
(p.spanRank < Cardinal.aleph0) = p.FG | false |
MvPolynomial.decomposition | Mathlib.RingTheory.MvPolynomial.Homogeneous | {σ : Type u_1} →
{R : Type u_3} → [inst : CommSemiring R] → DirectSum.Decomposition (MvPolynomial.homogeneousSubmodule σ R) | true |
Lean.pp.safeShadowing | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | true |
CategoryTheory.Over.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
{A : C} {X Y : CategoryTheory.Over A} (k : X ⟶ Y) (f g : CategoryTheory.Over A) (k_1 : f ⟶ g),
CategoryTheory.CategoryStruct.comp (X.coprodObj.map k_1)
(CategoryTheory.Over.homMk
(Cate... | false |
CategoryTheory.Distributive.«_aux_Mathlib_CategoryTheory_Distributive_Monoidal___macroRules_CategoryTheory_Distributive_term∂R_1» | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.Macro | false |
_private.Mathlib.MeasureTheory.Measure.LevyConvergence.0.MeasureTheory.isTightMeasureSet_of_tendsto_charFun._proof_1_6 | Mathlib.MeasureTheory.Measure.LevyConvergence | (3 + 1).AtLeastTwo | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (symPrios : Lean.Meta.Grind.SymbolPriorities) (minPrio : ℕ),
sizeOf { symPrios := symPrios, minPrio := minPrio } = 1 + sizeOf symPrios + sizeOf minPrio | true |
Lean.Kernel.Exception.unknownConstant.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
t.ctorIdx = 0 →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.unknownConstant env name)) →
motive t | false |
CategoryTheory.imageOpUnop | Mathlib.CategoryTheory.Abelian.Opposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → Opposite.unop (CategoryTheory.Limits.image f.op) ≅ CategoryTheory.Limits.image f | true |
UInt64.le_antisymm_iff | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b ↔ a ≤ b ∧ b ≤ a | true |
GaloisCoinsertion.liftCompleteLattice | Mathlib.Order.GaloisConnection.Basic | {α : Type u} →
{β : Type v} →
{l : α → β} →
{u : β → α} → [inst : PartialOrder α] → [inst_1 : CompleteLattice β] → GaloisCoinsertion l u → CompleteLattice α | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic.0.exists_continuous_add_one_of_isCompact_nnreal._simp_1_2 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | false |
SimpleGraph.UnitDistEmbedding.mk | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
[inst : MetricSpace E] → (p : V ↪ E) → (∀ {u v : V}, G.Adj u v → dist (p u) (p v) = 1) → G.UnitDistEmbedding E | true |
isProperMap_iff_isCompact_preimage | Mathlib.Topology.Maps.Proper.CompactlyGenerated | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space Y]
[CompactlyCoherentSpace Y] {f : X → Y},
IsProperMap f ↔ Continuous f ∧ ∀ ⦃K : Set Y⦄, IsCompact K → IsCompact (f ⁻¹' K) | true |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_2 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_1} {R' : Type u_2} {M : Type u_3} {M' : Type u_4} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_5} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | false |
_private.Mathlib.Analysis.Normed.Group.Bounded.0.Bornology.IsBounded.exists_pos_norm_le'.match_1_1 | Mathlib.Analysis.Normed.Group.Bounded | ∀ {E : Type u_1} [inst : SeminormedGroup E] {s : Set E} (motive : (∃ C, ∀ x ∈ s, ‖x‖ ≤ C) → Prop)
(x : ∃ C, ∀ x ∈ s, ‖x‖ ≤ C), (∀ (R₀ : ℝ) (hR₀ : ∀ x ∈ s, ‖x‖ ≤ R₀), motive ⋯) → motive x | false |
LinearMap.BilinForm.SeparatingRight.toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} {M₂ : Type u_4} [inst : CommRing R₂] [inst_1 : AddCommGroup M₂] [inst_2 : Module R₂ M₂] {ι : Type u_6}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {B : LinearMap.BilinForm R₂ M₂},
LinearMap.SeparatingRight B → ∀ (b : Module.Basis ι R₂ M₂), ((LinearMap.BilinForm.toMatrix b) B).SeparatingRight | true |
NumberField.mixedEmbedding.convexBodySum_isBounded | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ),
Bornology.IsBounded (NumberField.mixedEmbedding.convexBodySum K B) | true |
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {n : Q(ℕ)} →
{P : Sort u} →
{n' : Q(ℕ)} →
{pf : «$n» =Q «$n'».succ} →
{n'' : Q(ℕ)} →
{pf' : «$n» =Q «$n''».succ} →
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n' pf = Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n'' pf' →
(n' = n'' → P) → P | false |
Filter.EventuallyEq.isTheta | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {l : Filter α} {f g : α → E}, f =ᶠ[l] g → f =Θ[l] g | true |
Std.DTreeMap.Const.minKey!_modify_eq_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey! = t.minKey! | true |
Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (Q : Ideal S)
[inst_3 : Q.IsPrime] [Algebra.FiniteType R S] [Algebra.IsUnramifiedAt R Q], ∃ f ∉ Q, HasStandardEtaleSurjectionOn R f | true |
Std.Internal.Small.casesOn | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
{motive : Std.Internal.Small α → Sort u_1} →
(t : Std.Internal.Small α) → ((h : Nonempty (Std.Internal.ComputableSmall α)) → motive ⋯) → motive t | false |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.Measure.restrictₗ._simp_2 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_1} (a b c : Set α), a ∩ (b \ c) = (a ∩ b) \ c | false |
AlgebraicGeometry.PresheafedSpace.instInhabited | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → [Inhabited C] → Inhabited (AlgebraicGeometry.PresheafedSpace C) | true |
IsAlgClosure.of_exists_root | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[alg : Algebra.IsAlgebraic F E],
(∀ (p : Polynomial F), p.Monic → Irreducible p → ∃ x, (Polynomial.aeval x) p = 0) → IsAlgClosure F E | true |
CategoryTheory.Limits.MulticospanIndex.mk | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(left : J.L → C) →
(right : J.R → C) →
((b : J.R) → left (J.fst b) ⟶ right b) →
((b : J.R) → left (J.snd b) ⟶ right b) → CategoryTheory.Limits.MulticospanIndex J C | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
bddAbove_smul_iff_of_neg._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β]
{s : Set β} {a : α}, a < 0 → BddAbove (a • s) = BddBelow s | false |
Matrix.frobeniusNormedRing._proof_10 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_2} {α : Type u_1} [inst : Fintype m] [inst_1 : RCLike α] [inst_2 : DecidableEq m] (n : ℕ),
↑(n + 1) = ↑n + 1 | false |
ByteArray.utf8Decode?.eq_1 | Init.Data.String.Basic | ∀ (b : ByteArray), b.utf8Decode? = ByteArray.utf8Decode?.go b 0 #[] ⋯ | true |
_private.Batteries.Tactic.Init.0.Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1.match_1 | Batteries.Tactic.Init | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(ty? : Option (Lean.TSyntax `term)) →
((ty? : Lean.TSyntax `term) → motive (some ty?)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive ty? | false |
MvFunctor.exists_iff_exists_of_mono | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} {α β : TypeVec.{u} n} (F : TypeVec.{u} n → Type v) [inst : MvFunctor F] [LawfulMvFunctor F] {P : F α → Prop}
{q : F β → Prop} (f : α.Arrow β) (g : β.Arrow α),
TypeVec.comp f g = TypeVec.id → (∀ (u : F α), P u ↔ q (MvFunctor.map f u)) → ((∃ u, P u) ↔ ∃ u, q u) | true |
Lean.Lsp.SemanticTokenType.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} → ℕ → Sort (max 1 u) | false |
Subgroup.HasDetOne.recOn | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | {n : Type u_1} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
{R : Type u_2} →
[inst_2 : CommRing R] →
{Γ : Subgroup (GL n R)} →
{motive : Γ.HasDetOne → Sort u} →
(t : Γ.HasDetOne) →
((det_eq : ∀ {g : GL n R}, g ∈ Γ → Matrix.GeneralLinearGroup.d... | false |
String.Pos.next.congr_simp | Init.Data.String.Basic | ∀ {s : String} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos), pos.next h = pos_1.next ⋯ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.