name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
WithAbs.congr_trans | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} {U : Type u_4} [inst_3 : Semiring T] [inst_4 : Semiring U]
(w : AbsoluteValue T S) (u : AbsoluteValue U S) (f : R ≃+* T) (g : T ≃+* U),
WithAbs.congr v u (f.trans g) = (WithAbs.congr v w f).trans (WithAbs.congr w u g) | true |
Lean.Meta.Iterator.next | Lean.Meta.Iterator | {α : Type} → Lean.Meta.Iterator α → Lean.MetaM (Option (α × Lean.Meta.SavedState)) | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.stateLP | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.PositiveVector | {matType : ℕ → ℕ → Type} →
[Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
{n m : ℕ} → matType n m → List ℕ → matType (n + 2) (m + 3) | true |
Lean.Lsp.FileSystemWatcher.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileSystemWatcher → ℕ | false |
WithZero.lt_ofAdd_of_toAdd_unzero_lt | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α] {a : WithZero (Multiplicative α)} {b : α} (ha : a ≠ 0),
Multiplicative.toAdd (WithZero.unzero ha) < b → a < ↑(Multiplicative.ofAdd b) | true |
_private.Mathlib.Order.Filter.Prod.0.Filter.compl_mem_coprod._simp_1_2 | Mathlib.Order.Filter.Prod | ∀ {α : Type u} {f g : Filter α} {s : Set α}, (s ∈ f ⊔ g) = (s ∈ f ∧ s ∈ g) | false |
ContinuousAddEquiv._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousMonoidHom | (G : Type u) →
{inst : TopologicalSpace G} →
(H : Type v) →
{inst_1 : TopologicalSpace H} → {inst_2 : Add G} → {inst_3 : Add H} → [SizeOf G] → [SizeOf H] → SizeOf (G ≃ₜ+ H) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.of_forall_constGet?_eq._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 |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | true |
CategoryTheory.Functor.FullyFaithful.isMonHom_preimage | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {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.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] (hF : F.FullyFaithful) {X Y : C}
[inst_5 : CategoryTheory.MonObj X] [inst_6 : CategoryTheory.MonObj Y] (f : F.obj X ⟶ F.obj Y)
[CategoryTheory.IsMonHom f], CategoryTheory.IsMonHom (hF.preimage f) | true |
CochainComplex.HomComplex.Cochain.rightShiftLinearEquiv._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (R : Type u_3)
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] (K L : CochainComplex C ℤ) (n a n' : ℤ) (hn' : n' + a = n)
(x : R) (γ : CochainComplex.HomComplex.Cochain K L n),
(CochainComplex.HomComplex.Cochain.rightShiftAddEquiv K L n a n' hn') (x • γ) =
x • (CochainComplex.HomComplex.Cochain.rightShiftAddEquiv K L n a n' hn') γ | false |
Finite.of_injective | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_4} {β : Sort u_5} [Finite β] (f : α → β), Function.Injective f → Finite α | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl_obj | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl F).obj A = A.obj | true |
BitVec.reduceAllOnes._regBuiltin.BitVec.reduceAllOnes.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.214689512._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
CategoryTheory.MonoidalOpposite.tensorRightIso_inv_app_unmop | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X X_1 : Cᴹᵒᵖ),
(X.tensorRightIso.inv.app X_1).unmop =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X.unmop X_1.unmop) | true |
Ideal.mem_span_singleton' | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {x y : α}, x ∈ Ideal.span {y} ↔ ∃ a, a * y = x | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandDeclNamespace?.match_1 | Lean.Elab.Declaration | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((str : String) → motive (Lean.Name.anonymous.str str)) →
((pre : Lean.Name) → (shortName : String) → motive (pre.str shortName)) → ((x : Lean.Name) → motive x) → motive x | false |
SecondCountableTopology.rec | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{motive : SecondCountableTopology α → Sort u_1} →
((is_open_generated_countable : ∃ b, b.Countable ∧ t = TopologicalSpace.generateFrom b) → motive ⋯) →
(t : SecondCountableTopology α) → motive t | false |
Lean.Grind.NoopConfig.splits._default | Init.Grind.Config | ℕ | false |
NonemptyInterval.instCommSemiringOfCanonicallyOrderedAdd._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommSemiring α] [inst_1 : PartialOrder α] [inst_2 : CanonicallyOrderedAdd α],
autoParam (∀ (x : NonemptyInterval α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | false |
one_le_cfc_iff._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_private.Lean.Class.0.Lean.init | Lean.Class | IO Unit | true |
OrderIso.dualAntisymmetrization._proof_8 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a b : (Antisymmetrization α fun x1 x2 => x1 ≤ x2)ᵒᵈ),
{ toFun := Quotient.map' id ⋯, invFun := Quotient.map' id ⋯, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := Quotient.map' id ⋯, invFun := Quotient.map' id ⋯, left_inv := ⋯, right_inv := ⋯ } b ↔
a ≤ b | false |
_private.Init.Data.Array.Lemmas.0.Array.push_eq_push._simp_1_1 | Init.Data.Array.Lemmas | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
BitVec.getElem_signExtend | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {v i : ℕ} (h : i < v), (BitVec.signExtend v x)[i] = if h : i < w then x[i] else x.msb | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ArrowInfo.ctorIdx | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.ArrowInfo✝ → ℕ | false |
div_eq_zero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a b : G₀}, (a / b = 0) = (a = 0 ∨ b = 0) | false |
Int.Linear.le_of_le_diseq | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ p₂ p₃ : Int.Linear.Poly),
Int.Linear.le_of_le_diseq_cert p₁ p₂ p₃ = true →
Int.Linear.Poly.denote' ctx p₁ ≤ 0 → Int.Linear.Poly.denote' ctx p₂ ≠ 0 → Int.Linear.Poly.denote' ctx p₃ ≤ 0 | true |
Lean.Grind.CommRing.d_normEq0 | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (c : ℕ)
(init p₁ p₂ p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.d_normEq0_cert c p₁ p₂ p = true →
↑k * Lean.Grind.CommRing.Poly.denote ctx init = Lean.Grind.CommRing.Poly.denote ctx p₁ →
Lean.Grind.CommRing.Poly.denote ctx p₂ = 0 →
↑k * Lean.Grind.CommRing.Poly.denote ctx init = Lean.Grind.CommRing.Poly.denote ctx p | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodySum_volume._simp_1_9 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {L : Type u_5} [inst_4 : RCLike L]
(f : α → L) (g : β → L), (∫ (x : α), f x ∂μ) * ∫ (y : β), g y ∂ν = ∫ (z : α × β), f z.1 * g z.2 ∂μ.prod ν | false |
instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α], IsOrderedAddMonoid (Additive αᵒᵈ) | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.newDepHyp.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.newDepHyp✝ goal = Lean.Meta.Grind.IntroResult.newDepHyp✝¹ goal' → (goal = goal' → P) → P | false |
_private.Mathlib.RingTheory.LittleWedderburn.0.LittleWedderburn.InductionHyp.field._proof_1 | Mathlib.RingTheory.LittleWedderburn | ∀ {D : Type u_1} [inst : DivisionRing D] {R : Subring D}, IsDomain ↥R | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_cons_aux | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {x : α} {xs : List α}
{f : α → β} (hxs : xs ≠ []),
List.minIdxOn f (x :: xs) ⋯ = List.combineMinIdxOn✝ f (List.minIdxOn f [x] ⋯) (List.minIdxOn f xs hxs) ⋯ ⋯ | true |
Unitization.instMulOneClass._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_2} {A : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : DistribMulAction R A]
(x : Unitization R A), (1 * x).toProd.2 = x.toProd.2 | false |
Lean.Grind.OrderedAdd.add_le_add | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommMonoid M] [Lean.Grind.OrderedAdd M]
{a b c d : M}, a ≤ b → c ≤ d → a + c ≤ b + d | true |
Lean.MessageData.instCoeFormat | Lean.Message | Coe Std.Format Lean.MessageData | true |
CategoryTheory.Functor.preservesZeroMorphisms_of_isLeftAdjoint | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [F.IsLeftAdjoint], F.PreservesZeroMorphisms | true |
contDiffWithinAt_infty | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E}, ContDiffWithinAt 𝕜 (↑⊤) f s x ↔ ∀ (n : ℕ), ContDiffWithinAt 𝕜 (↑n) f s x | true |
CategoryTheory.Triangulated.Octahedron.rec | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
{X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} →
{u₁₂ : X₁ ⟶ X₂} →
{u₂₃ : X₂ ⟶ X₃} →
{u₁₃ : X₁ ⟶ X₃} →
{comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃} →
{v₁₂ : X₂ ⟶ Z₁₂} →
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₂ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₂₃ : X₃ ⟶ Z₂₃} →
{w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂} →
{h₂₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₁₃ : X₃ ⟶ Z₁₃} →
{w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{motive : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃ → Sort u} →
((m₁ : Z₁₂ ⟶ Z₁₃) →
(m₃ : Z₁₃ ⟶ Z₂₃) →
(comm₁ :
CategoryTheory.CategoryStruct.comp v₁₂ m₁ =
CategoryTheory.CategoryStruct.comp u₂₃ v₁₃) →
(comm₂ : CategoryTheory.CategoryStruct.comp m₁ w₁₃ = w₁₂) →
(comm₃ : CategoryTheory.CategoryStruct.comp v₁₃ m₃ = v₂₃) →
(comm₄ :
CategoryTheory.CategoryStruct.comp w₁₃
((CategoryTheory.shiftFunctor C 1).map u₁₂) =
CategoryTheory.CategoryStruct.comp m₃ w₂₃) →
(mem :
CategoryTheory.Pretriangulated.Triangle.mk m₁ m₃
(CategoryTheory.CategoryStruct.comp w₂₃
((CategoryTheory.shiftFunctor C 1).map v₁₂)) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
motive
{ m₁ := m₁, m₃ := m₃, comm₁ := comm₁, comm₂ := comm₂,
comm₃ := comm₃, comm₄ := comm₄, mem := mem }) →
(t : CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃) → motive t | false |
Equiv.Perm.IsCycleOn.of_inv | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {s : Set α}, f⁻¹.IsCycleOn s → f.IsCycleOn s | true |
Equiv.symm_preimage_preimage | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set β), ⇑e.symm ⁻¹' (⇑e ⁻¹' s) = s | true |
AlgebraicGeometry.Proj.zero_apply | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {V : (TopologicalSpace.Opens ↑(ProjectiveSpectrum.top 𝒜))ᵒᵖ} (x : ↥(Opposite.unop V)),
↑0 x = 0 | true |
Std.HashMap.Raw.isEmpty_inter_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁ ∩ m₂).isEmpty = true | true |
List.length_filter_pos_iff._simp_1 | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (0 < (List.filter p l).length) = ∃ x ∈ l, p x = true | false |
CategoryTheory.MorphismProperty.colimitsOfShape | Mathlib.CategoryTheory.MorphismProperty.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.MorphismProperty C →
(J : Type u_1) → [CategoryTheory.Category.{v_1, u_1} J] → CategoryTheory.MorphismProperty C | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology.0.ProjectiveSpectrum.instPartialOrder._simp_3 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {a : Prop}, (a → a) = True | false |
CategoryTheory.GrothendieckTopology.Cover.Relation.mk.inj | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} {fst snd : S.Arrow} {r : fst.Relation snd} {fst_1 snd_1 : S.Arrow} {r_1 : fst_1.Relation snd_1},
{ fst := fst, snd := snd, r := r } = { fst := fst_1, snd := snd_1, r := r_1 } → fst = fst_1 ∧ snd = snd_1 ∧ r ≍ r_1 | true |
CategoryTheory.Lax.OplaxTrans.rightUnitor | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(η : F ⟶ G) → CategoryTheory.CategoryStruct.comp η (CategoryTheory.CategoryStruct.id G) ≅ η | true |
Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound} →
t = t' → Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.noConfusionType P t t' | false |
Lean.Grind.ConfigInteractive.gen._inherited_default | Init.Grind.Config | ℕ | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.quasiIsoAt_π._simp_1_5 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i : ι) [inst_2 : K.HasHomology i],
CategoryTheory.CategoryStruct.id (K.homology i) =
HomologicalComplex.homologyMap (CategoryTheory.CategoryStruct.id K) i | false |
_private.Lean.Meta.Tactic.Grind.PP.0.Lean.Meta.Grind.Result.no.elim | Lean.Meta.Tactic.Grind.PP | {motive : Lean.Meta.Grind.Result✝ → Sort u} →
(t : Lean.Meta.Grind.Result✝¹) → Lean.Meta.Grind.Result.ctorIdx✝ t = 2 → motive Lean.Meta.Grind.Result.no✝ → motive t | false |
_private.Mathlib.Analysis.Normed.Module.Ball.Homeomorph.0.OpenPartialHomeomorph.univUnitBall._simp_6 | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
Polynomial.natDegree_removeFactor' | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] {f : Polynomial K} {n : ℕ}, f.natDegree = n + 1 → f.removeFactor.natDegree = n | true |
AddMonCat.adjoinZero._proof_2 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X Y Z : AddSemigrp} (x : X ⟶ Y) (x_1 : Y ⟶ Z),
AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom (CategoryTheory.CategoryStruct.comp x x_1))) =
CategoryTheory.CategoryStruct.comp (AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom x)))
(AddMonCat.ofHom (WithZero.mapAddHom (AddSemigrp.Hom.hom x_1))) | false |
AddCommGrpCat.forget_createsLimitsOfSize.eq_1 | Mathlib.Algebra.Category.Grp.Limits | AddCommGrpCat.forget_createsLimitsOfSize =
{ CreatesLimitsOfShape := fun {J} [CategoryTheory.Category.{w, v} J] => inferInstance } | true |
FirstOrder.Language.IsOrdered.casesOn | 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 |
CategoryTheory.uliftFunctorTrivial._proof_1 | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u_1} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftFunctor.{u_1, u_1}.map f)
(CategoryTheory.uliftTrivial Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftTrivial X).hom
((CategoryTheory.Functor.id (Type u_1)).map f) | false |
Module.IsTorsionBySet.hasSMul._proof_1 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R},
Module.IsTorsionBySet R M ↑I → Submodule.toAddSubgroup I ≤ (smulAddHom R M).ker | false |
IsSemiprimaryRing.isSemisimpleRing | Mathlib.RingTheory.Jacobson.Semiprimary | ∀ {R : Type u_1} {inst : Ring R} [self : IsSemiprimaryRing R], IsSemisimpleRing (R ⧸ Ring.jacobson R) | true |
ContinuousMap.instMulZeroClassOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : MulZeroClass β] → [ContinuousMul β] → MulZeroClass C(α, β) | true |
Std.HashMap.Raw.«term_~m_» | Std.Data.HashMap.Raw | Lean.TrailingParserDescr | true |
Lean.Environment.Replay.State.mk | Lean.Replay | Lean.Environment → Lean.NameSet → Lean.NameSet → Lean.NameSet → Lean.NameSet → Lean.Environment.Replay.State | true |
_private.Mathlib.Order.Filter.CountableInter.0.Filter.mem_countableGenerate_iff._simp_1_1 | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), (a ⊆ a) = True | false |
Path.extend_of_le_zero | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a b : X} (γ : Path a b) {t : ℝ}, t ≤ 0 → γ.extend t = a | true |
inv_mul_le_one_of_le₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b : G₀}
[ZeroLEOneClass G₀], a ≤ b → 0 ≤ b → b⁻¹ * a ≤ 1 | true |
IsZLattice.basis._proof_2 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] (L : Submodule ℤ (ι → ℝ)) [DiscreteTopology ↥L], Module.Free ℤ ↥L | false |
CategoryTheory.Presieve.CoverByImageStructure.mk.inj | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {D : Type u_2}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {G : CategoryTheory.Functor C D} {V U : D} {f : V ⟶ U} {obj : C}
{lift : V ⟶ G.obj obj} {map : G.obj obj ⟶ U}
{fac :
autoParam (CategoryTheory.CategoryStruct.comp lift map = f)
CategoryTheory.Presieve.CoverByImageStructure.fac._autoParam}
{obj_1 : C} {lift_1 : V ⟶ G.obj obj_1} {map_1 : G.obj obj_1 ⟶ U}
{fac_1 :
autoParam (CategoryTheory.CategoryStruct.comp lift_1 map_1 = f)
CategoryTheory.Presieve.CoverByImageStructure.fac._autoParam},
{ obj := obj, lift := lift, map := map, fac := fac } = { obj := obj_1, lift := lift_1, map := map_1, fac := fac_1 } →
obj = obj_1 ∧ lift ≍ lift_1 ∧ map ≍ map_1 | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.match_1 | Lean.Environment | (motive : Option Lean.RealizationContext✝ → Sort u_1) →
(x : Option Lean.RealizationContext✝¹) →
((ctx : Lean.RealizationContext✝²) → motive (some ctx)) → (Unit → motive none) → motive x | false |
ContMDiffAt.clm_comp | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F₁ : Type u_8} [inst_6 : NormedAddCommGroup F₁]
[inst_7 : NormedSpace 𝕜 F₁] {F₂ : Type u_9} [inst_8 : NormedAddCommGroup F₂] [inst_9 : NormedSpace 𝕜 F₂]
{F₃ : Type u_10} [inst_10 : NormedAddCommGroup F₃] [inst_11 : NormedSpace 𝕜 F₃] {n : WithTop ℕ∞} {g : M → F₁ →L[𝕜] F₃}
{f : M → F₂ →L[𝕜] F₁} {x : M},
ContMDiffAt I (modelWithCornersSelf 𝕜 (F₁ →L[𝕜] F₃)) n g x →
ContMDiffAt I (modelWithCornersSelf 𝕜 (F₂ →L[𝕜] F₁)) n f x →
ContMDiffAt I (modelWithCornersSelf 𝕜 (F₂ →L[𝕜] F₃)) n (fun x => (g x).comp (f x)) x | true |
CliffordAlgebra.even.lift.aux | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] → CliffordAlgebra.EvenHom Q A → ↥(CliffordAlgebra.even Q) →ₗ[R] A | true |
_private.Lean.Meta.Tactic.Simp.Arith.Int.Basic.0.Lean.Meta.Simp.Arith.Int.ToLinear.run.match_1 | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {α : Type} →
(motive : α × Lean.Meta.Simp.Arith.Int.ToLinear.State → Sort u_1) →
(__discr : α × Lean.Meta.Simp.Arith.Int.ToLinear.State) →
((a : α) → (s : Lean.Meta.Simp.Arith.Int.ToLinear.State) → motive (a, s)) → motive __discr | false |
Std.instAntisymmLeOfIsPartialOrder | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [Std.IsPartialOrder α], Std.Antisymm fun x1 x2 => x1 ≤ x2 | true |
Lean.Lsp.instFromJsonReferenceParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.ReferenceParams | true |
Std.DTreeMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.DTreeMap α (fun x => Unit) cmp} [Std.TransCmp cmp] {l : List α}
{k k' : α},
cmp k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
k ∈ l → (Std.DTreeMap.Const.insertManyIfNewUnit t l).getKey? k' = some k | true |
op_smul_mul | Mathlib.Algebra.Group.Action.Opposite | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid α] [inst_1 : MulAction αᵐᵒᵖ β] (b : β) (a₁ a₂ : α),
MulOpposite.op (a₁ * a₂) • b = MulOpposite.op a₂ • MulOpposite.op a₁ • b | true |
Module.IsReflexive.of_split | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] [Module.IsReflexive R M] (i : N →ₗ[R] M)
(s : M →ₗ[R] N), s ∘ₗ i = LinearMap.id → Module.IsReflexive R N | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} →
{w : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput old w →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 : DecidableEq α'] →
{old' : Std.Sat.AIG α'} →
{w' : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastDivSubtractShiftOutput old' w' → Sort u | false |
Topology.WithUpperSet.map | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → C(Topology.WithUpperSet α, Topology.WithUpperSet β) | true |
DomMulAct.map_mk_nhds | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M] (x : M), Filter.map (⇑DomMulAct.mk) (nhds x) = nhds (DomMulAct.mk x) | true |
CategoryTheory.CartesianCopyDiscard.ofCartesianMonoidalCategory | Mathlib.CategoryTheory.CopyDiscardCategory.Cartesian | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → CategoryTheory.CopyDiscardCategory C | true |
small_plift | Mathlib.Logic.Small.Defs | ∀ (α : Type u) [Small.{v, u} α], Small.{v, u + 1} (PLift α) | true |
Mathlib.Tactic._aux_Mathlib_Tactic_CasesM___elabRules_Mathlib_Tactic_casesM_1 | Mathlib.Tactic.CasesM | Lean.Elab.Tactic.Tactic | false |
CategoryTheory.Limits.WalkingReflexivePair.Hom.right | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | CategoryTheory.Limits.WalkingReflexivePair.one.Hom CategoryTheory.Limits.WalkingReflexivePair.zero | true |
CategoryTheory.zigzag_equivalence | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J], Equivalence CategoryTheory.Zigzag | true |
AffineMap.homothety._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} [inst : CommRing k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1],
SMulCommClass k k V1 | false |
OrderIso.refl_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} [inst : LE α] (x : α), (OrderIso.refl α) x = x | true |
CategoryTheory.Discrete.addMonoidal._proof_11 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : AddMonoid M] (X : CategoryTheory.Discrete M), X.as + 0 = X.as | false |
CommCStarAlgebra.toNonUnitalCommCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ (A : Type u_1) [inst : CommCStarAlgebra A] (a : A), 0 + a = a | false |
ChartedSpace.liftPropWithinAt_subtypeVal_comp_iff | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop}
{U : TopologicalSpace.Opens M'} (f : M → ↥U) (s : Set M) (x : M),
ChartedSpace.LiftPropWithinAt P (Subtype.val ∘ f) s x ↔ ChartedSpace.LiftPropWithinAt P f s x | true |
UniformCauchySeqOn.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {s : Set β},
UniformCauchySeqOn f l s → UniformCauchySeqOn f' l s → UniformCauchySeqOn (fun i i_1 => f i i_1 - f' i i_1) l s | true |
Finset.image₂_congr' | Mathlib.Data.Finset.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [inst : DecidableEq γ] {f f' : α → β → γ} {s : Finset α} {t : Finset β},
(∀ (a : α) (b : β), f a b = f' a b) → Finset.image₂ f s t = Finset.image₂ f' s t | true |
List.getElem?_partialProds | Batteries.Data.List.Scan | ∀ {α : Type u_1} {i : ℕ} [inst : Mul α] [inst_1 : One α] [Std.Associative fun x1 x2 => x1 * x2]
[Std.LawfulIdentity (fun x1 x2 => x1 * x2) 1] {l : List α},
l.partialProds[i]? = if i ≤ l.length then some (List.take i l).prod else none | true |
CategoryTheory.MorphismProperty.Comma.mapRightIso_unitIso_hom_app_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative] [inst_4 : W.IsMultiplicative]
{R₁ R₂ : CategoryTheory.Functor B T} [inst_5 : P.RespectsIso] [inst_6 : Q.RespectsIso] [inst_7 : W.RespectsIso]
(e : R₁ ≅ R₂) (X : CategoryTheory.MorphismProperty.Comma L R₁ P Q W),
((CategoryTheory.MorphismProperty.Comma.mapRightIso L e).unitIso.hom.app X).right =
CategoryTheory.CategoryStruct.id X.right | true |
SSet.oneTruncation₂_obj | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (S : SSet.Truncated 2), SSet.oneTruncation₂.obj S = CategoryTheory.ReflQuiv.of (SSet.OneTruncation₂ S) | true |
nullMeasurableSet_region_between_cc | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {f g : α → ℝ},
AEMeasurable f μ →
AEMeasurable g μ →
∀ {s : Set α},
MeasureTheory.NullMeasurableSet s μ →
MeasureTheory.NullMeasurableSet {p | p.1 ∈ s ∧ p.2 ∈ Set.Icc (f p.1) (g p.1)} (μ.prod MeasureTheory.volume) | true |
AddCircle.homeomorphCircle'_apply | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ (θ : Real.Angle), AddCircle.homeomorphCircle' θ = θ.toCircle | true |
Lean.Meta.Simp.mainCore | Lean.Meta.Tactic.Simp.Main | Lean.Expr →
Lean.Meta.Simp.Context →
optParam Lean.Meta.Simp.State { } →
optParam Lean.Meta.Simp.Methods { } → Lean.MetaM (Lean.Meta.Simp.Result × Lean.Meta.Simp.State) | true |
NormedSpace.induced._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ {F : Type u_1} (𝕜 : Type u_4) (E : Type u_2) (G : Type u_3) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : FunLike F E G]
[LinearMapClass F 𝕜 E G], AddMonoidHomClass F E G | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.