name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Int.reduceBdiv._regBuiltin.Int.reduceBdiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1571464712._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
LinearMap.smulRight_zero | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {S : Type u_3} {M : Type u_4} {M₁ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [inst_5 : Semiring S] [inst_6 : Module R S]
[inst_7 : Module S M] [inst_8 : IsScalarTower R S M] (f : M₁ →ₗ[R] S), f.smulRight 0 = 0 | true |
ApplicativeTransformation.mk.sizeOf_spec | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
[inst_2 : (a : Type u) → SizeOf (F a)] [inst_3 : (a : Type u) → SizeOf (G a)] (app : (α : Type u) → F α → G α)
(preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x)
(preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app β (x <*> y) = app (α → β) x <*> app α y),
sizeOf { app := app, preserves_pure' := preserves_pure', preserves_seq' := preserves_seq' } = 1 | true |
ENNReal.eq_of_forall_nnreal_iff | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r ≤ x ↔ ↑r ≤ y) → x = y | true |
DirectLimit.instDivisionSemiring._proof_15 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → DivisionSemiring (G i)] [inst_6 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)]
(a : DirectLimit G f), 1 * a = a | false |
toLexMulEquiv.eq_1 | Mathlib.Algebra.Order.Group.Equiv | ∀ (α : Type u_1) [inst : Mul α], toLexMulEquiv α = { toEquiv := toLex, map_mul' := ⋯ } | true |
ContDiffAt.snd' | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {f : F → G} {x : E} {y : F},
ContDiffAt 𝕜 n f y → ContDiffAt 𝕜 n (fun x => f x.2) (x, y) | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_19 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (k' : α) (v' : β k'),
Std.DTreeMap.Internal.Impl.leaf.size - 1 ≤
(Std.DTreeMap.Internal.Impl.inner 1 k' v' Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | false |
IsSelfAdjoint.toReal_spectralRadius_eq_norm | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a : A}, IsSelfAdjoint a → (spectralRadius ℝ a).toReal = ‖a‖ | true |
AlgebraicGeometry.Scheme.JointlySurjective.recOn | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {K : CategoryTheory.Precoverage AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.Scheme.JointlySurjective K → Sort u_1} →
(t : AlgebraicGeometry.Scheme.JointlySurjective K) →
((exists_eq : ∀ {X : AlgebraicGeometry.Scheme}, ∀ S ∈ K.coverings X, ∀ (x : ↥X), ∃ Y g, S g ∧ x ∈ Set.range ⇑g) →
motive ⋯) →
motive t | false |
contMDiffWithinAt_iff_of_mem_source' | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M} {x : M}
{n : WithTop ℕ∞} [IsManifold I n M] [IsManifold I' n M'] {x' : M} {y : M'},
x' ∈ (chartAt H x).source →
f x' ∈ (chartAt H' y).source →
(ContMDiffWithinAt I I' n f s x' ↔
ContinuousWithinAt f s x' ∧
ContDiffWithinAt 𝕜 n (↑(extChartAt I' y) ∘ f ∘ ↑(extChartAt I x).symm)
((extChartAt I x).target ∩ ↑(extChartAt I x).symm ⁻¹' (s ∩ f ⁻¹' (extChartAt I' y).source))
(↑(extChartAt I x) x')) | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.SummationFilter.symmetricIcc_eq_symmetricIoo_int._proof_1_13 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ (s : Set (Finset ℤ)),
(∃ a, ∀ (b : ℕ), a ≤ b → Finset.Icc (-↑b) ↑b ∈ s) →
∀ (a b : ℕ), a + 1 ≤ b → ∀ (a_1 : ℤ), -↑b < a_1 ∧ a_1 < ↑b ↔ -↑(b - 1) ≤ a_1 ∧ a_1 ≤ ↑(b - 1) | false |
CategoryTheory.MorphismProperty.instIsStableUnderTransfiniteCompositionOfShapeFunctorFunctorCategoryOfHasIterationOfShape | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (K : Type u')
[inst_1 : LinearOrder K] [inst_2 : SuccOrder K] [inst_3 : OrderBot K] [inst_4 : WellFoundedLT K]
[W.IsStableUnderTransfiniteCompositionOfShape K] (J : Type u'') [inst_6 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasIterationOfShape K C], (W.functorCategory J).IsStableUnderTransfiniteCompositionOfShape K | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.exists_finsupp_eq_lexOrder_of_ne_zero._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_1} {x : WithTop α}, (x ≠ ⊤) = ∃ a, ↑a = x | false |
RingHom.mk'._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : NonAssocSemiring α] [inst_1 : NonAssocRing β] (f : α →* β)
(map_add : ∀ (a b : α), f (a + b) = f a + f b) (x y : α),
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun (x + y) =
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun x + (↑(AddMonoidHom.mk' (⇑f) map_add)).toFun y | false |
_private.Mathlib.Data.List.Basic.0.List.mem_getLast?_eq_getLast._proof_1_14 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (a b : α) (l : List α), ¬(a :: b :: l).length - 1 = 0 → (a :: b :: l).length - 2 < (b :: l).length | false |
Ring.KrullDimLE.subsingleton_primeSpectrum | Mathlib.RingTheory.KrullDimension.Zero | ∀ (R : Type u_1) [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [IsLocalRing R], Subsingleton (PrimeSpectrum R) | true |
id_tensor_π_preserves_coequalizer_inv_colimMap_desc | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
{X Y Z X' Y' Z' : C} (f g : X ⟶ Y) (f' g' : X' ⟶ Y') (p : CategoryTheory.MonoidalCategoryStruct.tensorObj Z X ⟶ X')
(q : CategoryTheory.MonoidalCategoryStruct.tensorObj Z Y ⟶ Y')
(wf :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f) q =
CategoryTheory.CategoryStruct.comp p f')
(wg :
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) q =
CategoryTheory.CategoryStruct.comp p g')
(h : Y' ⟶ Z') (wh : CategoryTheory.CategoryStruct.comp f' h = CategoryTheory.CategoryStruct.comp g' h),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z (CategoryTheory.Limits.coequalizer.π f g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.PreservesCoequalizer.iso (CategoryTheory.MonoidalCategory.tensorLeft Z) f g).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimMap
(CategoryTheory.Limits.parallelPairHom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z f)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Z g) f' g' p q wf wg))
(CategoryTheory.Limits.coequalizer.desc h wh))) =
CategoryTheory.CategoryStruct.comp q h | true |
_private.Lean.Compiler.LCNF.Internalize.0.Lean.Compiler.LCNF.Internalize.internalizeCodeDecl.match_4 | Lean.Compiler.LCNF.Internalize | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1) →
(decl : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.CodeDecl.fun decl h)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.jp decl)) →
((fvarId : Lean.FVarId) →
(i : ℕ) →
(y : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.uset fvarId i y h)) →
((fvarId : Lean.FVarId) →
(i offset : ℕ) →
(y : Lean.FVarId) →
(ty : Lean.Expr) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.sset fvarId i offset y ty h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check offset : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.inc fvarId n check offset h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check offset : Bool) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.CodeDecl.dec fvarId n check offset h)) →
motive decl | false |
EReal.top_ne_coe._simp_1 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (⊤ = ↑x) = False | false |
Subsemiring.coe_prod._simp_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (s : Subsemiring R)
(t : Subsemiring S), ↑s ×ˢ ↑t = ↑(s.prod t) | false |
QuadraticMap.zeroHomClass | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], ZeroHomClass (QuadraticMap R M N) M N | true |
Std.DTreeMap.Internal.Impl.balanceL!_pair_congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {k' : α} {v' : β k'},
⟨k, v⟩ = ⟨k', v'⟩ →
∀ {l l' r r' : Std.DTreeMap.Internal.Impl α β},
l = l' → r = r' → Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balanceL! k' v' l' r' | true |
Module.mapEvalEquiv | Mathlib.LinearAlgebra.Dual.Defs | (R : Type u_3) →
(M : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.IsReflexive R M] → Submodule R M ≃o Submodule R (Module.Dual R (Module.Dual R M)) | true |
SimplexCategory.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i.castSucc) (SimplexCategory.σ j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j) (SimplexCategory.δ i) | true |
_private.Mathlib.Algebra.Polynomial.UnitTrinomial.0.Polynomial.isUnitTrinomial_iff'._simp_1_1 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | false |
Polynomial.SplittingField.instCharZero | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K) [CharZero K], CharZero f.SplittingField | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_3 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | false |
FreeGroup.isReduced_iff_reduce_eq | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.IsReduced L ↔ FreeGroup.reduce L = L | true |
instLTBitVec | Init.Prelude | {w : ℕ} → LT (BitVec w) | true |
PMF.uniformOfFintype_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α] (a : α), (PMF.uniformOfFintype α) a = (↑(Fintype.card α))⁻¹ | true |
ciSup_eq_ite | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderSup α] {p : Prop} [inst_1 : Decidable p] {f : p → α},
⨆ (h : p), f h = if h : p then f h else sSup ∅ | true |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.disjoint_support_closure_of_disjoint_support._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u_1} {t : Set α} {ι : Sort u_12} {s : ι → Set α}, Disjoint t (⋃ i, s i) = ∀ (i : ι), Disjoint t (s i) | false |
Pi.mulSingle_le_mulSingle._gcongr_3 | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : DecidableEq ι] [inst_1 : (i : ι) → One (α i)]
[inst_2 : (i : ι) → Preorder (α i)] {i : ι} {a b : α i}, a ≤ b → Pi.mulSingle i a ≤ Pi.mulSingle i b | false |
ISize.toInt_maxValue | Init.Data.SInt.Lemmas | ISize.maxValue.toInt = 2 ^ (System.Platform.numBits - 1) - 1 | true |
_private.Mathlib.Tactic.Find.0.Mathlib.Tactic.Find.matchHyps | Mathlib.Tactic.Find | List Lean.Expr → List Lean.Expr → List Lean.Expr → Lean.MetaM Bool | true |
LaurentSeries.val_le_one_iff_eq_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : LaurentSeries K), Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f | true |
Lean.Lsp.DiagnosticCode | Lean.Data.Lsp.Diagnostics | Type | true |
Ordnode.eraseMin._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α | false |
UpperSet.coe_nonempty | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s).Nonempty ↔ s ≠ ⊤ | true |
_private.Mathlib.RingTheory.Lasker.0.Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite._simp_1_9 | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] {f : M →ₗ[R] M'}
[inst_5 : IsLocalizedModule S f] {m : M} {s : ↥S} {m' : M'}, (IsLocalizedModule.mk' f m s = m') = (f m = s • m') | false |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isBitVecValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool | true |
ContinuousMap.instRegularSpace | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [RegularSpace Y],
RegularSpace C(X, Y) | true |
Std.IterM.Partial.it | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM.Partial m β → Std.IterM m β | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.map._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {Δ' Δ : SimplexCategoryᵒᵖ} (θ : Δ ⟶ Δ') (A : SimplicialObject.Splitting.IndexSet Δ),
CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp θ.unop A.e) | false |
Algebra.TensorProduct.tensorQuotientEquiv_symm_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A] (I : Ideal T) (a : A) (t : T),
(Algebra.TensorProduct.tensorQuotientEquiv S T A I).symm
((Ideal.Quotient.mk (Ideal.map Algebra.TensorProduct.includeRight I)) (a ⊗ₜ[R] t)) =
a ⊗ₜ[R] (Ideal.Quotient.mk I) t | true |
Std.ExtTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (_ : α) × β}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | true |
String.Slice.Pattern.Model.IsValidSearchFrom.mismatched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
startPos' < endPos →
(∀ (pos : s.Pos), startPos' ≤ pos → pos < endPos → ¬String.Slice.Pattern.Model.MatchesAt pat pos) →
startPos = startPos' →
String.Slice.Pattern.Model.IsValidSearchFrom pat startPos'
(String.Slice.Pattern.SearchStep.rejected startPos endPos :: l) | true |
Std.ExtDHashMap.mem_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, k' ∈ m.modify k f ↔ k' ∈ m | true |
CategoryTheory.MonoidalCategory.whiskerLeftIso_trans | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (W : C)
{X Y Z : C} (f : X ≅ Y) (g : Y ≅ Z),
CategoryTheory.MonoidalCategory.whiskerLeftIso W (f ≪≫ g) =
CategoryTheory.MonoidalCategory.whiskerLeftIso W f ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso W g | true |
List.isEmpty_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse.isEmpty = xs.isEmpty | true |
Std.TreeSet.Raw.insertMany_list_equiv_foldl | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet.Raw α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) | true |
CategoryTheory.ComposableArrows.homMkSucc | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{n : ℕ} →
{F G : CategoryTheory.ComposableArrows C (n + 1)} →
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) →
(β : F.δ₀ ⟶ G.δ₀) →
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β 0 ⋯) =
CategoryTheory.CategoryStruct.comp α (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯) →
(F ⟶ G) | true |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.commute_iff_of_isUnit._simp_1_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M ≃ₗ[R] M}
{p : Submodule R M}, (p ≤ Submodule.map (↑f) p) = (p ∈ Module.End.invtSubmodule ↑f.symm) | false |
Ideal.quotientEquivDirectSum | Mathlib.LinearAlgebra.FreeModule.IdealQuotient | {ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : IsDomain R] →
[inst_4 : IsPrincipalIdealRing R] →
[inst_5 : IsDomain S] →
[inst_6 : Finite ι] →
(F : Type u_4) →
[inst_7 : CommRing F] →
[inst_8 : Algebra F R] →
[inst_9 : Algebra F S] →
[IsScalarTower F R S] →
(b : Module.Basis ι R S) →
{I : Ideal S} →
(hI : I ≠ ⊥) →
(S ⧸ I) ≃ₗ[F] DirectSum ι fun i => R ⧸ Ideal.span {Ideal.smithCoeffs b I hI i} | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.logUnassignedUsingErrorInfos.match_1 | Lean.Elab.Term.TermElabM | (motive : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool) → Sort u_1) →
(r : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool)) →
((alreadyVisited : Lean.MVarIdSet) →
(errors : Array Lean.Elab.Term.MVarErrorInfo) →
(hasNewErrors : Bool) → motive ⟨alreadyVisited, errors, hasNewErrors⟩) →
motive r | false |
CategoryTheory.Functor.DenseAt.ofIso | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → {Y : D} → F.DenseAt Y → {Y' : D} → (Y ≅ Y') → F.DenseAt Y' | true |
Option.merge.eq_4 | Init.Omega.Constraint | ∀ {α : Type u_1} (fn : α → α → α) (x_2 y : α), Option.merge fn (some x_2) (some y) = some (fn x_2 y) | true |
Lean.Server.RequestCancellation._sizeOf_1 | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | false |
SemiRingCat.FilteredColimits.colimitCoconeIsColimit._proof_2 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F),
(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t) 1 = 1 | false |
ContinuousLinearEquiv.equivLike._proof_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_1} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
[inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (f g : M₁ ≃SL[σ₁₂] M₂),
(↑f.toLinearEquiv).toFun = (↑g.toLinearEquiv).toFun → f.invFun = g.invFun → f = g | false |
Lean.FindLevelMVar.main._unsafe_rec | Lean.Util.FindLevelMVar | (Lean.LMVarId → Bool) → Lean.Expr → Lean.FindLevelMVar.Visitor | false |
CategoryTheory.Enriched.FunctorCategory.homEquiv_apply_π_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F₁ F₂ : CategoryTheory.Functor J C}
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂] (τ : F₁ ⟶ F₂) (j : J) {Z : V}
(h : (F₁.obj j ⟶[V] F₂.obj j) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Enriched.FunctorCategory.homEquiv V) τ)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomπ V F₁ F₂ j) h) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.eHomEquiv V) (τ.app j)) h | true |
FirstCountableTopology.frechetUrysohnSpace | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [FirstCountableTopology X], FrechetUrysohnSpace X | true |
Int.cast_le_neg_one_of_neg | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, a < 0 → ↑a ≤ -1 | true |
WithZero.instAddMonoidWithOne | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [AddMonoidWithOne α] → AddMonoidWithOne (WithZero α) | true |
lt_of_mul_self_lt_mul_self₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ b → a * a < b * b → a < b | true |
Module.piEquiv | Mathlib.LinearAlgebra.StdBasis | (ι : Type u_1) →
(R : Type u_2) →
(M : Type u_3) →
[Finite ι] →
[inst : CommSemiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (ι → M) ≃ₗ[R] (ι → R) →ₗ[R] M | true |
Orientation.rotationAux._proof_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle) (x y : V),
inner ℝ ((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) x)
((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) y) =
inner ℝ x y | false |
Valuation.RankLeOne.mk._flat_ctor | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → (hom' : MonoidWithZeroHom.ValueGroup₀ v →*₀ NNReal) → StrictMono ⇑hom' → v.RankLeOne | false |
ContinuousLinearMap.bilinear_hasTemperateGrowth | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {𝕜 : Type u_2} {D : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_7} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NontriviallyNormedField 𝕜] [NormedAlgebra ℝ 𝕜] [inst_6 : NormedAddCommGroup D] [inst_7 : NormedSpace ℝ D]
[inst_8 : NormedAddCommGroup G] [inst_9 : NormedSpace ℝ G] [inst_10 : NormedSpace 𝕜 F] [inst_11 : NormedSpace 𝕜 G]
[inst_12 : NormedSpace 𝕜 E] (B : E →L[𝕜] F →L[𝕜] G) {f : D → E} {g : D → F},
Function.HasTemperateGrowth f → Function.HasTemperateGrowth g → Function.HasTemperateGrowth fun x => (B (f x)) (g x) | true |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_orderEmbedding_getElem?_eq._simp_1_1 | Mathlib.Data.List.NodupEquivFin | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | false |
Lean.Grind.ToInt.toInt.eq_1 | Init.GrindInstances.ToInt | ∀ (α : Type u) {range : Lean.Grind.IntInterval} [self : Lean.Grind.ToInt α range], Lean.Grind.ToInt.toInt = self.1 | true |
Lean.Meta.Try.Collector.OrdSet.set | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Lean.Meta.Try.Collector.OrdSet α → Std.HashSet α | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
hasStrictDerivAt_abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt (fun x => |x|) (↑(SignType.sign x)) x | true |
DistribSMul.toAddMonoidHom_eq_zsmulAddGroupHom | Mathlib.Algebra.Module.NatInt | ∀ (M : Type u_3) [inst : AddCommGroup M], DistribSMul.toAddMonoidHom M = zsmulAddGroupHom | true |
Representation.IntertwiningMap.rTensor_zero | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A G W}
{τ : Representation A G U}, Representation.IntertwiningMap.rTensor ρ 0 = 0 | true |
Fin.dfoldrM.loop._sunfold | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) | false |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_6, u_3} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) (A : Type u_5) [inst_2 : CategoryTheory.Category.{u_2, u_5} A]
[inst_3 : G.LocallyCoverDense K] [inst_4 : G.IsLocallyFull K] [inst_5 : G.IsLocallyFaithful K]
[inst_6 : G.IsCoverDense K]
[∀ (X : Dᵒᵖ), CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.StructuredArrow X G.op) A],
(G.sheafPushforwardContinuous A (G.inducedTopology K) K).IsEquivalence | false |
matPolyEquiv_symm_map_eval | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Polynomial (Matrix n n R)) (r : R),
(matPolyEquiv.symm M).map (Polynomial.eval r) = Polynomial.eval ((Matrix.scalar n) r) M | true |
StdSimplex.join._proof_2 | Mathlib.LinearAlgebra.ConvexSpace | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] {M : Type u_2} [IsStrictOrderedRing R]
(f : StdSimplex R (StdSimplex R M)), 0 ≤ f.sum fun d r => r • d.weights | false |
MonoidWithZero.toOppositeMulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | (M₀ : Type u_2) → [inst : MonoidWithZero M₀] → MulActionWithZero M₀ᵐᵒᵖ M₀ | true |
Module.Basis.dualBasis_coord_toDualEquiv_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (i : ι) (f : M),
(b.dualBasis.coord i) (b.toDualEquiv f) = (b.coord i) f | true |
Lean.Parser.Module.module.formatter | Lean.Parser.Module | Lean.PrettyPrinter.Formatter | true |
Module.Basis.noConfusionType | Mathlib.LinearAlgebra.Basis.Defs | Sort u →
{ι : Type u_1} →
{R : Type u_3} →
{M : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
Module.Basis ι R M →
{ι' : Type u_1} →
{R' : Type u_3} →
{M' : Type u_6} →
[inst' : Semiring R'] →
[inst'_1 : AddCommMonoid M'] → [inst'_2 : Module R' M'] → Module.Basis ι' R' M' → Sort u | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.minKey!_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Std.Internal.List.getValueCast_alterKey._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (k k' : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k' (Std.Internal.List.alterKey k f l) = true →
(k == k') = true → (f (Std.Internal.List.getValueCast? k l)).isSome = true | false |
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_11) (A : Type u_12) [inst : CommSemiring R] [inst_1 : Fintype n]
[inst_2 : Fintype m] [inst_3 : DecidableEq m] [inst_4 : DecidableEq n] [inst_5 : Semiring A] [inst_6 : Algebra R A]
(e : m ≃ n) (M N : Matrix m m A),
(Matrix.reindexAlgEquiv R A e) M * (Matrix.reindexAlgEquiv R A e) N = (Matrix.reindexAlgEquiv R A e) (M * N) | false |
RingQuot.instSemiring._proof_14 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), a * 1 = a | false |
Colex.instSMul'.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {x : Type u_2} {x_1 : Type u_1} [h : SMul x x_1], Colex.instSMul' = h | true |
Batteries.RBNode.Balanced.nil | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1}, Batteries.RBNode.nil.Balanced Batteries.RBColor.black 0 | true |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.asiegel.eq_1 | Mathlib.NumberTheory.NumberField.House | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {α : Type u_2} {β : Type u_3}
(a : Matrix α β (NumberField.RingOfIntegers K)) (k : α × (K →+* ℂ)) (l : β × (K →+* ℂ)),
NumberField.house.asiegel✝ K a k l = NumberField.house.a'✝ K a k.1 l.1 l.2 k.2 | true |
Con.congr.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M} (h : c = d),
Con.congr h = { toEquiv := Quotient.congr (Equiv.refl M) ⋯, map_mul' := ⋯ } | true |
Nat.le_sqrt | Mathlib.Data.Nat.Sqrt | ∀ {m n : ℕ}, m ≤ n.sqrt ↔ m * m ≤ n | true |
_private.Init.Data.Int.LemmasAux.0.Int.sub_max_sub_left._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬max (a - b) (a - c) = a - min b c → False | false |
Int.lt_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a < b → b ≤ c → a < c | true |
Qq.SortLocalDecls.State.ctorIdx | Qq.SortLocalDecls | Qq.SortLocalDecls.State → ℕ | false |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | false |
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | {α : outParam (Type u)} →
{β : outParam (Type v)} →
{inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} →
{σ : Type w} →
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} →
[self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] → σ → Prop | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.