name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Submodule.starProjection_inj | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E} [inst_3 : U.HasOrthogonalProjection] [inst_4 : V.HasOrthogonalProjection],
U.starProjection = V.starProjection ↔ U = V | true |
BiheytingHom.id_comp | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : BiheytingAlgebra α] [inst_1 : BiheytingAlgebra β] (f : BiheytingHom α β),
(BiheytingHom.id β).comp f = f | true |
_private.Batteries.Data.String.Lemmas.0.String.foldlAux_of_valid.match_1_1 | Batteries.Data.String.Lemmas | ∀ {α : Type u_1} (motive : List Char → List Char → List Char → α → Prop) (x x_1 x_2 : List Char) (x_3 : α),
(∀ (l r : List Char) (a : α), motive l [] r a) →
(∀ (l : List Char) (c : Char) (m r : List Char) (a : α), motive l (c :: m) r a) → motive x x_1 x_2 x_3 | false |
BoundedLatticeHom.toInfTopHom | Mathlib.Order.Hom.BoundedLattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Lattice α] →
[inst_1 : Lattice β] →
[inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedLatticeHom α β → InfTopHom α β | true |
SSet.Edge.map_id | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X Y : SSet} (x₀ : X.obj (Opposite.op (SimplexCategory.mk 0))) (f : X ⟶ Y),
(SSet.Edge.id x₀).map f = SSet.Edge.id (f.app (Opposite.op (SimplexCategory.mk 0)) x₀) | true |
GroupExtension.Equiv.ofMonoidHom._proof_6 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_4} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_1} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_3} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E'),
S'.rightHom.comp f = S.rightHom → ⇑(S'.rightHom.comp f) = ⇑S.rightHom | false |
EisensteinSeries.r1.eq_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), EisensteinSeries.r1 z = z.im ^ 2 / (z.re ^ 2 + z.im ^ 2) | true |
CategoryTheory.Limits.Cofork.IsColimit.homIso_natural | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {t : CategoryTheory.Limits.Cofork f g}
{Z Z' : C} (q : Z ⟶ Z') (ht : CategoryTheory.Limits.IsColimit t) (k : t.pt ⟶ Z),
↑((CategoryTheory.Limits.Cofork.IsColimit.homIso ht Z') (CategoryTheory.CategoryStruct.comp k q)) =
CategoryThe... | true |
continuousWithinAt_iff_continuous_left'_right'._to_dual_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace β]
{s : Set α} {a : α} {f : α → β},
ContinuousWithinAt f s a ↔ ContinuousWithinAt f (s ∩ Set.Ioi a) a ∧ ContinuousWithinAt f (s ∩ Set.Iio a) a | false |
_private.Mathlib.Tactic.Lift.0.Mathlib.Tactic.Lift.main.match_3 | Mathlib.Tactic.Lift | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(newVarName : Option (Lean.TSyntax `ident)) →
((v : Lean.TSyntax `ident) → motive (some v)) → (Unit → motive none) → motive newVarName | false |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.measure_pos_eq_zero_of_hasSubGaussianMGF_zero._simp_1_2 | Mathlib.Probability.Moments.SubGaussian | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
Std.Roc.Sliceable.rec | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Roc.Sliceable α β γ → Sort u_1} →
((mkSlice : α → Std.Roc β → γ) → motive { mkSlice := mkSlice }) → (t : Std.Roc.Sliceable α β γ) → motive t | false |
HomotopicalAlgebra.AttachCells.ofArrowIso._proof_1 | Mathlib.AlgebraicTopology.RelativeCellComplex.AttachCells | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {α : Type u_4} {A B : α → C} {g : (a : α) → A a ⟶ B a}
{X₁ X₂ : C} {f : X₁ ⟶ X₂} (c : HomotopicalAlgebra.AttachCells g f) {Y₁ Y₂ : C} {f' : Y₁ ⟶ Y₂}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk f'),
CategoryTheory.IsPushout (CategoryTheory... | false |
WithTop.add_right_inj | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithTop α} [IsRightCancelAdd α], z ≠ ⊤ → (x + z = y + z ↔ x = y) | true |
CategoryTheory.Comonad.comparison._proof_3 | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R) (X : C),
CategoryTheory.CategoryStruct.comp (L.map (h.unit.app X)) (h.toComonad.δ.app (L.obj X)) =
Categor... | false |
RatFunc.intDegree_add_le | Mathlib.FieldTheory.RatFunc.Degree | ∀ {K : Type u} [inst : Field K] {x y : RatFunc K}, y ≠ 0 → x + y ≠ 0 → (x + y).intDegree ≤ max x.intDegree y.intDegree | true |
SimpleGraph.TripartiteFromTriangles.toTriangle.match_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (a' : α) (b' : β) (c' : γ), motive (a', b', c')) → motive x | false |
LiouvilleWith.mul_rat_iff | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {r : ℚ}, r ≠ 0 → (LiouvilleWith p (x * ↑r) ↔ LiouvilleWith p x) | true |
Module.IsTorsionFree.of_faithfulSMul | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[FaithfulSMul R A] [inst_4 : Semiring S] [inst_5 : Module S R] [inst_6 : Module S A] [IsScalarTower S R A]
[Module.IsTorsionFree S A], Module.IsTorsionFree S R | true |
AddOpposite.opUniformEquivRight._proof_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous AddOpposite.op | false |
CategoryTheory.Triangulated.TStructure.triangleLEGEIsoTriangleLTGE._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, 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]
(t : CategoryT... | false |
Int.tdiv_left_inj | Init.Data.Int.DivMod.Lemmas | ∀ {a b d : ℤ}, d ∣ a → d ∣ b → (a.tdiv d = b.tdiv d ↔ a = b) | true |
Module.eqIdeal._proof_3 | Mathlib.RingTheory.Ideal.Defs | ∀ (R : Type u_1) {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m m' : M),
0 ∈ {r | r • m = r • m'} | false |
measurableSet_generateFrom_of_mem_supClosure | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {s : Set (Set α)} {t : Set α}, t ∈ supClosure s → MeasurableSet t | true |
Std.TreeSet.Raw.isEmpty_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.insert k).isEmpty = false | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_finset_disjoint_balls_large_measure._simp_1_20 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
Std.DTreeMap.Internal.Unit.RooSliceData | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → [Ord α] → Type u | true |
MeasureTheory.projectiveFamilyContent_eq | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
(MeasureTheory.projectiveFamilyContent hP) s = MeasureTheory.projectiveFamilyFun P s | true |
norm_add₄_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a b c d : E}, ‖a + b + c + d‖ ≤ ‖a‖ + ‖b‖ + ‖c‖ + ‖d‖ | true |
_private.Mathlib.AlgebraicGeometry.Scheme.0.AlgebraicGeometry.basicOpen_eq_of_affine._simp_1_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
CategoryTheory.Functor.whiskerRight_id | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {G : CategoryTheory.Functor C D}
(F : CategoryTheory.Functor D E),
CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.id G) ... | true |
DirectSum.SetLike.IsHomogeneous | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
(ℳ : ι → σ) → [DirectSum.Decomposition ℳ] → {P : Type u_5} → [SetLike P M] → P → Prop | true |
MulOpposite.instNonUnitalNormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : NonUnitalNormedRing α] (a b : αᵐᵒᵖ), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | false |
Graded.subtypeMap | Mathlib.Data.FunLike.Graded | {F : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : FunLike F A B] → [GradedFunLike F 𝒜 ℬ] →... | true |
smoothSheafCommGroup.compLeft | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_2} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_3} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_4} →
... | true |
Representation.mapSubmodule._proof_15 | Mathlib.RepresentationTheory.Submodule | ∀ {k : Type u_3} {G : Type u_2} {V : Type u_1} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (q : Submodule (MonoidAlgebra k G) ρ.asModule),
(fun p =>
let __AddSubmonoid := AddSubmonoid.map ρ.asModuleEquiv.symm (↑p).toAddSubmonoid;
... | false |
LieDerivation.coe_sub_linearMap | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(D1 D2 : LieDerivation R L M), ↑(D1 - D2) = ↑D1 - ↑D2 | true |
LLVM.instNonemptyBasicBlock | Lean.Compiler.IR.LLVMBindings | ∀ {Context : Sort u_1} {ctx : Context}, Nonempty (LLVM.BasicBlock ctx) | true |
Std.ExtHashMap.getKey?_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m₁ ∩ m₂).getKey? k = if k ∈ m₂ then m₁.getKey? k else none | true |
Lean.Lsp.SemanticTokenType.decorator.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.decorator = 1 | true |
_private.Mathlib.Analysis.MeanInequalities.0.NNReal.Lr_rpow_le_Lp_mul_Lq._simp_1_6 | Mathlib.Analysis.MeanInequalities | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Icc_div._proof_1_9 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} {a b : Fin n} (f : Fin (n + 1) → M) (x : ℕ),
↑a ≤ x ∧ x ≤ ↑b →
(if h : x < n then f ⟨x + 1, ⋯⟩ / f ⟨x, ⋯⟩ else 1) =
(if h : x < n then f ⟨x + 1, ⋯⟩ else 1) / if h : x ≤ n then f ⟨x, ⋯⟩ else 1 | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceXOr.declare_73._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.370586403._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
List.takeWhile_cons_of_pos | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, p a = true → List.takeWhile p (a :: l) = a :: List.takeWhile p l | true |
Lean.Expr.const.injEq | Lean.Expr | ∀ (declName : Lean.Name) (us : List Lean.Level) (declName_1 : Lean.Name) (us_1 : List Lean.Level),
(Lean.Expr.const declName us = Lean.Expr.const declName_1 us_1) = (declName = declName_1 ∧ us = us_1) | true |
Array.getElem_setIfInBounds | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {j : ℕ} (hj : j < xs.size),
(xs.setIfInBounds i a)[j] = if i = j then a else xs[j] | true |
_private.Mathlib.Algebra.Category.Grp.Basic.0.CommGrpCat.Hom.mk._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} → (↑A →* ↑B) → A.Hom B | false |
Prod.instExistsAddOfLE | Mathlib.Algebra.Order.Monoid.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : Add α] [inst_3 : Add β] [ExistsAddOfLE α]
[ExistsAddOfLE β], ExistsAddOfLE (α × β) | true |
Std.Internal.Small.mk._flat_ctor | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v}, Nonempty (Std.Internal.ComputableSmall α) → Std.Internal.Small α | false |
Finset.nonempty_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β}, (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty | true |
MonoidAlgebra.mapDomainNonUnitalRingHom_comp | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} {O : Type u_8} [inst : Semiring R] [inst_1 : Mul M] [inst_2 : Mul N]
[inst_3 : Mul O] (f : N →ₙ* O) (g : M →ₙ* N),
MonoidAlgebra.mapDomainNonUnitalRingHom R (f.comp g) =
(MonoidAlgebra.mapDomainNonUnitalRingHom R f).comp (MonoidAlgebra.mapDomainNonUnitalRingHom R g... | true |
OrderMonoidHom.copy._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →*o β) (f' : α → β) (h : f' = ⇑f) (x y : α),
(↑(f.copy f' h)).toFun (x * y) = (↑(f.copy f' h)).toFun x * (↑(f.copy f' h)).toFun y | false |
Lean.Elab.Term.MatchAltView.mk.inj | Lean.Elab.MatchAltView | ∀ {k : Lean.SyntaxNodeKinds} {ref : Lean.Syntax} {patterns : Array Lean.Syntax} {lhs : Lean.Syntax}
{rhs : Lean.TSyntax k} {ref_1 : Lean.Syntax} {patterns_1 : Array Lean.Syntax} {lhs_1 : Lean.Syntax}
{rhs_1 : Lean.TSyntax k},
{ ref := ref, patterns := patterns, lhs := lhs, rhs := rhs } =
{ ref := ref_1, pat... | true |
WithZeroTopology.tendsto_of_ne_zero | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {l : Filter α} {f : α → Γ₀} {γ : Γ₀},
γ ≠ 0 → (Filter.Tendsto f l (nhds γ) ↔ ∀ᶠ (x : α) in l, f x = γ) | true |
NumberField.mixedEmbedding.norm_le_convexBodySumFun | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.mixedSpace K),
‖x‖ ≤ NumberField.mixedEmbedding.convexBodySumFun x | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.X | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} → {S : C} → (self : F.PreOneHypercoverDenseData S) → self.I₀ → C₀ | true |
Std.HashSet.any_eq_true_iff_exists_mem_get | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [LawfulHashable α] [EquivBEq α] {p : α → Bool},
m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p (m.get a h) = true | true |
Pointed.coe_of | Mathlib.CategoryTheory.Category.Pointed | ∀ {X : Type u_1} (point : X), (Pointed.of point).X = X | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup'._simp_1_2 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {p : α ×' β → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | false |
CategoryTheory.Limits.instDecidableEqWalkingReflexivePair | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | DecidableEq CategoryTheory.Limits.WalkingReflexivePair | true |
SubMulAction.mem_carrier | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] {p : SubMulAction R M} {x : M}, x ∈ p.carrier ↔ x ∈ ↑p | true |
Lean.Parser.ParserAliasInfo.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAliasInfo → Sort u} →
(t : Lean.Parser.ParserAliasInfo) →
((declName : Lean.Name) →
(stackSz? : Option ℕ) →
(autoGroupArgs : Bool) →
motive { declName := declName, stackSz? := stackSz?, autoGroupArgs := autoGroupArgs }) →
motive t | false |
LocallyConstant.congrRightₗ._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] {Z : Type u_3} (R : Type u_4) [inst_1 : Semiring R]
[inst_2 : AddCommMonoid Y] [inst_3 : Module R Y] [inst_4 : AddCommMonoid Z] [inst_5 : Module R Z] (e : Y ≃ₗ[R] Z),
Function.RightInverse (LocallyConstant.congrRight e.toEquiv).invFun (LocallyConstant.cong... | false |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.exists_lt_of_lt_ciSup.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} [inst : ConditionallyCompleteLinearOrder α] {b : α} {f : ι → α}
(motive : (∃ a ∈ Set.range f, b < a) → Prop) (x : ∃ a ∈ Set.range f, b < a),
(∀ (i : ι) (h : b < f i), motive ⋯) → motive x | false |
Lean.Firefox.FrameTable.Entry.noConfusionType | Lean.Util.Profiler | Sort u → Lean.Firefox.FrameTable.Entry → Lean.Firefox.FrameTable.Entry → Sort u | false |
MulLECancellable.le_mul_iff_one_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : MulOneClass α] [MulLeftMono α] {a b : α},
MulLECancellable a → (a ≤ a * b ↔ 1 ≤ b) | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_1 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {s : Set α}, (Set.range f ⊆ s) = ∀ (y : ι), f y ∈ s | false |
Nat.add_sub_cancel | Init.Data.Nat.Basic | ∀ (n m : ℕ), n + m - m = n | true |
«term_⁻ᵐ» | Mathlib.Algebra.Notation | Lean.TrailingParserDescr | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_2 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, (0 < a - b) = (b < a) | false |
FirstOrder.Language.Embedding.map_rel | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Embedding M N) {n : ℕ} (r : L.Relations n) (x : Fin n → M),
FirstOrder.Language.Structure.RelMap r (⇑φ ∘ x) ↔ FirstOrder.Language.Structure.RelMap r x | true |
AddSubgroup.map._proof_3 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_2} [inst : AddGroup G] {N : Type u_1} [inst_1 : AddGroup N] (f : G →+ N) (H : AddSubgroup G),
0 ∈ (AddSubmonoid.map f H.toAddSubmonoid).carrier | false |
ProbabilityTheory.Kernel.IndepSets.union_iff._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α},
ProbabilityTheory.Kernel.IndepSets (s₁ ∪ s₂) s' κ μ =
(ProbabilityTheory.Kernel.IndepSets s₁ s' κ μ ∧ ProbabilityTheory.Kernel.IndepSets ... | false |
CategoryTheory.Hopf.instCategory | Mathlib.CategoryTheory.Monoidal.Hopf_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Category.{v₁, max u₁ v₁} (CategoryTheory.Hopf C) | true |
instSliceableSubarrayNat_8 | Init.Data.Slice.Array.Basic | {α : Type u} → Std.Rii.Sliceable (Subarray α) ℕ (Subarray α) | true |
ISize.toUSize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.toUSize (OfNat.ofNat n) = OfNat.ofNat n | true |
CategoryTheory.ShortComplex.FunctorEquivalence.unitIso._proof_10 | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_3) [inst : CategoryTheory.Category.{u_4, u_1} J]
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.ShortComplex (CategoryTheory.Functor J C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.... | false |
UpperSet.instMax._proof_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s t : UpperSet α), IsUpperSet (↑s ∩ ↑t) | false |
AlgebraNorm.recOn | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{motive : AlgebraNorm R S → Sort u} →
(t : AlgebraNorm R S) →
((toRingNorm : RingNorm S) →
(smul' : ∀ (a : R) (x : S), toRingNorm.toFun... | false |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.Step.length.match_1_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (motive : (x x_1 : List (α × Bool)) → FreeGroup.Red.Step x x_1 → Prop) (x x_1 : List (α × Bool))
(x_2 : FreeGroup.Red.Step x x_1),
(∀ (L1 L2 : List (α × Bool)) (x : α) (b : Bool), motive (L1 ++ (x, b) :: (x, !b) :: L2) (L1 ++ L2) ⋯) →
motive x x_1 x_2 | false |
Similar.index_map | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂],
Similar v₁ v₂ → ∀ (f : ι' → ι), Similar (v₁ ∘ f) (v₂ ∘ f) | true |
AddMonoidAlgebra.domCongr._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (A : Type u_1) {M : Type u_2} {N : Type u_3} [inst : Semiring A] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N) (x y : AddMonoidAlgebra A M),
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun (x + y) =
(AddMonoidAlgebra.mapDomainRingEquiv A e).toFun x + (AddMonoidAlgebra.mapDomainRingEquiv A e).toFu... | false |
Finset.neg_smul_finset | Mathlib.Algebra.Ring.Action.Pointwise.Finset | ∀ {R : Type u_1} {G : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup G] [inst_2 : Module R G] [inst_3 : DecidableEq G]
{t : Finset G} {a : R}, -a • t = -(a • t) | true |
NonarchimedeanAddGroup | Mathlib.Topology.Algebra.Nonarchimedean.Basic | (G : Type u_1) → [AddGroup G] → [TopologicalSpace G] → Prop | true |
HomogeneousLocalization.AtPrime | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} → [inst : CommRing A] → [SetLike σ A] → (ι → σ) → (𝔭 : Ideal A) → [𝔭.IsPrime] → Type (max u_1 u_2) | true |
LinearPMap.sSup_le | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {c : Set (E →ₗ.[R] F)} (hc : DirectedOn (fun x1 x2 => x1 ≤ x2) c)
{g : E →ₗ.[R] F}, (∀ f ∈ c, f ≤ g) → LinearPMap.sSup c hc ≤ g | true |
Mathlib.Linter.TextBased.ErrorFormat.rec | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorFormat → Sort u} →
motive Mathlib.Linter.TextBased.ErrorFormat.humanReadable →
motive Mathlib.Linter.TextBased.ErrorFormat.exceptionsFile →
motive Mathlib.Linter.TextBased.ErrorFormat.github → (t : Mathlib.Linter.TextBased.ErrorFormat) → motive t | false |
Std.IterM.mapM.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β] [inst_1 : Monad n]
[inst_2 : MonadAttach n] [inst_3 : MonadLiftT m n] (f : β → n γ) (it : Std.IterM m β),
Std.IterM.mapM f it = Std.IterM.mapWithPostcondition (fun b => Std.Iterators.PostconditionT.attachLift (f b)) it | true |
unitInterval.symm_lt_comm | Mathlib.Topology.UnitInterval | ∀ {i j : ↑unitInterval}, unitInterval.symm i < j ↔ unitInterval.symm j < i | true |
RelSeries.mem_toList._simp_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r} {x : α}, (x ∈ s.toList) = (x ∈ s) | false |
Set.mem_image_equiv._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) | false |
AddCommGroup.toDivisionAddCommMonoid.eq_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G],
AddCommGroup.toDivisionAddCommMonoid =
{ toSubNegMonoid := inst.toSubNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯, add_comm := ⋯ } | true |
MonoidAlgebra.lift | 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 : Monoid M] → (M →* A) ≃ (MonoidAlgebra R M →ₐ[R] A) | true |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp_inv | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (α : F ⟶ G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
(α.naturality (CategoryTheory.CategoryStruct.comp f g)).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bic... | true |
MeasureTheory.stoppedValue_stoppedProcess | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] [inst_1 : LinearOrder ι] {u : ι → Ω → β}
{τ σ : Ω → WithTop ι},
MeasureTheory.stoppedValue (MeasureTheory.stoppedProcess u τ) σ = fun ω =>
if σ ω ≠ ⊤ then MeasureTheory.stoppedValue u (fun ω => min (σ ω) (τ ω)) ω
else MeasureTheory.stoppedVa... | true |
Set.nonempty_image_addRight_neg_inter_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {s t : Set α} {a : α},
((fun x => x + -a) '' s ∩ t).Nonempty ↔ ((fun x => a + x) '' (-s) ∩ -t).Nonempty | true |
Std.Slice.foldlM_toArray | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
[Std.LawfulIteratorLoop α Id m] [Std.Iterators.Finite α Id] [LawfulMonad m] {s : Std.Slice γ} {init : δ}
{f : δ →... | true |
_private.Mathlib.Topology.Closure.0.exists_isClosed_iff.match_1_1 | Mathlib.Topology.Closure | ∀ {X : Type u_1} [inst : TopologicalSpace X] {p : Set X → Prop} (motive : (∃ t, IsClosed t ∧ p t) → Prop)
(x : ∃ t, IsClosed t ∧ p t), (∀ (w : Set X) (h : IsClosed w ∧ p w), motive ⋯) → motive x | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.ClassifyInvariantUseResult.ctorElimType | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | {motive : Lean.Elab.Tactic.Do.ClassifyInvariantUseResult✝ → Sort u} → ℕ → Sort (max 1 u) | false |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk._proof_4 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{u_3, u_1} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(iso₁ : A.comp CategoryTheory.Pretriangulated.Triangle.π₁ ≅ B.comp Categ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.