name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Batteries.Tactic._aux_Batteries_Tactic_NoMatch___elabRules_Batteries_Tactic_matchWithDot_1 | Batteries.Tactic.NoMatch | Lean.Elab.Term.TermElab | false |
ProbabilityTheory.«termEVar[_]» | Mathlib.Probability.Moments.Variance | Lean.ParserDescr | true |
Array.all_filterMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β} {p : β → Bool},
(Array.filterMap f xs).all p =
xs.all fun a =>
match f a with
| some b => p b
| none => true | true |
List.findIdx_add_mem_findIdxs | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} (s : ℕ),
List.findIdx p xs < xs.length → List.findIdx p xs + s ∈ List.findIdxs p xs s | true |
String.getUTF8Byte | Init.Data.String.PosRaw | (s : String) → (p : String.Pos.Raw) → p < s.rawEndPos → UInt8 | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.shouldTranslateUnsafe.visit.match_1 | Mathlib.Tactic.Translate.Core | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → ((x : Lean.Expr) → motive x) → motive f | false |
CategoryTheory.MonoidalCategory.tensorHom_comp_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {V W X Y Z : C}
(f : V ⟶ W) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft W h) =
CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.CategoryStruct.comp g h) | true |
CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac_assoc | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Balanced C] {n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)} (hS : S.Exact) (k : ℕ)
(hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1)
[h₁ : (hS.sc k ⋯).HasRightHomology] [h₂ : (hS.sc (k + 1) ⋯).HasLeftHomology] {Z : C} (h : S.obj ⟨k + 1 + 1, ⋯⟩ ⟶ Z),
CategoryTheory.CategoryStruct.comp (hS.sc k ⋯).pOpcycles
(CategoryTheory.CategoryStruct.comp (hS.opcyclesIsoCycles k ⋯).hom
(CategoryTheory.CategoryStruct.comp (hS.sc (k + 1) ⋯).iCycles h)) =
CategoryTheory.CategoryStruct.comp (S.map' (k + 1) (k + 2) ⋯ ⋯) h | true |
CategoryTheory.Presieve.isSheaf_sup | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C] (K L : CategoryTheory.Coverage C)
(P : CategoryTheory.Functor Cᵒᵖ (Type u_1)),
CategoryTheory.Presieve.IsSheaf (K ⊔ L).toGrothendieck P ↔
CategoryTheory.Presieve.IsSheaf K.toGrothendieck P ∧ CategoryTheory.Presieve.IsSheaf L.toGrothendieck P | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.StarAlgEquiv.eq_linearIsometryEquivConjStarAlgEquiv._simp_1_3 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} {R₃ : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} {M₁ : Type u_4} [inst_3 : TopologicalSpace M₁]
[inst_4 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_5 : TopologicalSpace M₂] [inst_6 : AddCommMonoid M₂] {M₃ : Type u_7}
[inst_7 : TopologicalSpace M₃] [inst_8 : AddCommMonoid M₃] {M₄ : Type u_8} [inst_9 : TopologicalSpace M₄]
[inst_10 : AddCommMonoid M₄] [inst_11 : Module R₁ M₁] [inst_12 : Module R₂ M₂] [inst_13 : Module R₃ M₃]
[inst_14 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {R₄ : Type u_9} [inst_15 : Semiring R₄] [inst_16 : Module R₄ M₄]
{σ₁₄ : R₁ →+* R₄} {σ₂₄ : R₂ →+* R₄} {σ₃₄ : R₃ →+* R₄} [inst_17 : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄]
[inst_18 : RingHomCompTriple σ₂₃ σ₃₄ σ₂₄] [inst_19 : RingHomCompTriple σ₁₂ σ₂₄ σ₁₄] (h : M₃ →SL[σ₃₄] M₄)
(g : M₂ →SL[σ₂₃] M₃) (f : M₁ →SL[σ₁₂] M₂), h.comp (g.comp f) = (h.comp g).comp f | false |
ContinuousMultilinearMap.toContinuousLinearMap | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
[inst_5 : (i : ι) → TopologicalSpace (M₁ i)] →
[inst_6 : TopologicalSpace M₂] →
ContinuousMultilinearMap R M₁ M₂ → [DecidableEq ι] → ((i : ι) → M₁ i) → (i : ι) → M₁ i →L[R] M₂ | true |
Array.uget.eq_1 | Init.Data.Array.Basic | ∀ {α : Type u} (xs : Array α) (i : USize) (h : i.toNat < xs.size), xs.uget i h = xs[i.toNat] | true |
List.eraseP_subset | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.eraseP p l ⊆ l | true |
instAddCommGroupWithOneGradedTensorProduct._proof_30 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_3) {ι : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
Plausible.Nat.shrinkable | Plausible.Sampleable | Plausible.Shrinkable ℕ | true |
Std.ExtHashMap.getElem_filter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → Bool} {k : α} {h' : k ∈ Std.ExtHashMap.filter f m},
(Std.ExtHashMap.filter f m)[k] = m[k] | true |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.down._proof_2 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} J] {F : CategoryTheory.Functor J (Type u_3)}
{c : F.CoconeTypes} (hc : c.IsColimitCore) {T : Type u_2} {f g : c.pt → T}, (∀ (j : J), f ∘ c.ι j = g ∘ c.ι j) → f = g | false |
Lean.Lsp.CallHierarchyPrepareParams.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CallHierarchyPrepareParams → Sort u} →
(t : Lean.Lsp.CallHierarchyPrepareParams) →
((toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams) →
motive { toTextDocumentPositionParams := toTextDocumentPositionParams }) →
motive t | false |
FractionalIdeal.mk0.congr_simp | Mathlib.RingTheory.ClassGroup | ∀ {R : Type u_1} (K : Type u_2) [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDomain R] [inst_5 : IsDedekindDomain R],
FractionalIdeal.mk0 K = FractionalIdeal.mk0 K | true |
instModuleZModOfNatNatAdditiveUnitsInt._proof_7 | Mathlib.Data.ZMod.IntUnitsPower | ∀ (z₁ z₂ : ZMod 2) (au : Additive ℤˣ), (z₁ + z₂) • au = z₁ • au + z₂ • au | false |
ContinuousAlternatingMap.prod | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_4} →
{N' : Type u_5} →
{ι : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R N] →
[inst_6 : TopologicalSpace N] →
[inst_7 : AddCommMonoid N'] →
[inst_8 : Module R N'] →
[inst_9 : TopologicalSpace N'] → M [⋀^ι]→L[R] N → M [⋀^ι]→L[R] N' → M [⋀^ι]→L[R] (N × N') | true |
Std.DHashMap.Internal.AssocList.getCast!._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] → [LawfulBEq α] → (a : α) → [Inhabited (β a)] → Std.DHashMap.Internal.AssocList α β → β a | false |
LinearEquiv.prodProdProdComm_toAddEquiv | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) (M₃ : Type y) (M₄ : Type z) [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : AddCommMonoid M₄] [inst_5 : Module R M]
[inst_6 : Module R M₂] [inst_7 : Module R M₃] [inst_8 : Module R M₄],
↑(LinearEquiv.prodProdProdComm R M M₂ M₃ M₄) = AddEquiv.prodProdProdComm M M₂ M₃ M₄ | true |
_aux_Mathlib_GroupTheory_GroupAction_Hom___unexpand_MulActionHom_2 | Mathlib.GroupTheory.GroupAction.Hom | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind.mkProof.match_1 | Mathlib.Tactic.Translate.TagUnfoldBoundary | (motive : Mathlib.Tactic.Translate.CastKind✝ → Sort u_1) →
(x : Mathlib.Tactic.Translate.CastKind✝¹) →
(Unit → motive Mathlib.Tactic.Translate.CastKind.eq✝) →
((x : Mathlib.Tactic.Translate.CastKind✝²) → motive x) → motive x | false |
_private.Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric.0.ordinaryHypergeometric_radius_top_of_neg_nat₁._proof_1_2 | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {k : ℕ} (n : ℕ), k < n + (1 + k) | false |
fourierCoeffOn_of_hasDeriv_right | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ} {n : ℤ},
n ≠ 0 →
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Set.Ioi x) x) →
IntervalIntegrable f' MeasureTheory.volume a b →
fourierCoeffOn hab f n =
1 / (-2 * ↑Real.pi * Complex.I * ↑n) *
((fourier (-n)) ↑a * (f b - f a) - (↑b - ↑a) * fourierCoeffOn hab f' n) | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.sPolynomial_decomposition._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R) (a : R), MvPolynomial.C a * p = a • p | false |
Set.EquicontinuousWithinAt | Mathlib.Topology.UniformSpace.Equicontinuity | {X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → Set (X → α) → Set X → X → Prop | true |
CategoryTheory.ObjectProperty.IsSeparating.isSeparator_coproduct | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {β : Type w}
{f : β → C} [inst_2 : CategoryTheory.Limits.HasCoproduct f],
(CategoryTheory.ObjectProperty.ofObj f).IsSeparating → CategoryTheory.IsSeparator (∐ f) | true |
Algebra.Presentation.instCommRingCore._proof_41 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ},
autoParam
(∀ (n : ℕ) (a : P.Core),
Algebra.Presentation.instCommRingCore._aux_37 (Int.negSucc n) a =
-Algebra.Presentation.instCommRingCore._aux_37 (↑n.succ) a)
SubNegMonoid.zsmul_neg'._autoParam | false |
Aesop.instMonadParentDeclStateRefT'_aesop | Aesop.Util.Basic | {m : Type → Type} → {ω σ : Type} → [Lean.Elab.MonadParentDecl m] → Lean.Elab.MonadParentDecl (StateRefT' ω σ m) | true |
Filter.Realizer.bind._proof_16 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_2} {β : Type u_1} {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G : (i : α) → (m i).Realizer)
(x : Set β),
x ∈
{
f := fun x =>
match x with
| ⟨s, f_1⟩ => ⋃ i, ⋃ (h : i ∈ F.F.f s), (G i).F.f (f_1 i h),
pt := ⟨F.F.pt, fun i x => (G i).F.pt⟩,
inf := fun x x_1 =>
match x with
| ⟨a, f_1⟩ =>
match x_1 with
| ⟨b, f'⟩ => ⟨F.F.inf a b, fun i h => (G i).F.inf (f_1 i ⋯) (f' i ⋯)⟩,
inf_le_left := ⋯, inf_le_right := ⋯ }.toFilter.sets ↔
x ∈ (f.bind m).sets | false |
CategoryTheory.NormalEpi.regularEpi | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(f : X ⟶ Y) → [I : CategoryTheory.NormalEpi f] → CategoryTheory.RegularEpi f | true |
Filter.NeBot.one_le_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Group α] {f : Filter α}, f.NeBot → 1 ≤ f / f | true |
Std.ExtDTreeMap.keys_filter.match_1 | Std.Data.ExtDTreeMap.Lemmas | {α : Type u_1} →
{β : α → Type u_2} →
{cmp : α → α → Ordering} →
{t : Std.ExtDTreeMap α β cmp} →
[inst : Std.TransCmp cmp] →
(motive : { x // x ∈ t.keys } → Sort u_3) →
(x : { x // x ∈ t.keys }) → ((x : α) → (h' : x ∈ t.keys) → motive ⟨x, h'⟩) → motive x | false |
LinearEquiv.mem_transvections._simp_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {f : Module.Dual R V}
{v : V} (hfv : f v = 0), (LinearEquiv.transvection hfv ∈ LinearEquiv.transvections R V) = True | false |
Combinatorics.Line.ColorFocused.recOn | Mathlib.Combinatorics.HalesJewett | {α : Type u_5} →
{ι : Type u_6} →
{κ : Type u_7} →
{C : (ι → Option α) → κ} →
{motive : Combinatorics.Line.ColorFocused C → Sort u} →
(t : Combinatorics.Line.ColorFocused C) →
((lines : Multiset (Combinatorics.Line.AlmostMono C)) →
(focus : ι → Option α) →
(is_focused : ∀ p ∈ lines, ↑p.line none = focus) →
(distinct_colors : (Multiset.map Combinatorics.Line.AlmostMono.color lines).Nodup) →
motive
{ lines := lines, focus := focus, is_focused := is_focused,
distinct_colors := distinct_colors }) →
motive t | false |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.card_commonNeighbors_eq_of_adj_compl._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | false |
Batteries.Tactic.GeneralizeProofs.AState._sizeOf_1 | Batteries.Tactic.GeneralizeProofs | Batteries.Tactic.GeneralizeProofs.AState → ℕ | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.finMulAntidiag_eq_piFinset_divisors_filter.match_1_4 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {d m n : ℕ} (f : Fin d → ℕ) (motive : (∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) ∧ ∏ i, f i = m → Prop)
(x : (∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) ∧ ∏ i, f i = m),
(∀ (left : ∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) (hprod : ∏ i, f i = m), motive ⋯) → motive x | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException.rec | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException → Sort u} →
motive Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException.infeasible →
(t : Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException) → motive t | false |
_private.Mathlib.RingTheory.Ideal.Prime.0.Ideal.not_isPrime_iff.match_1_8 | Mathlib.RingTheory.Ideal.Prime | ∀ {α : Type u_1} [inst : Semiring α] {I : Ideal α} (motive : (∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I) → Prop)
(x : ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I),
(∀ (x : α) (hx : x ∉ I) (y : α) (hy : y ∉ I) (hxy : x * y ∈ I), motive ⋯) → motive x | false |
Ordinal.epsilon0_eq_nfp | Mathlib.SetTheory.Ordinal.Veblen | Ordinal.epsilon 0 = Ordinal.nfp (fun a => Ordinal.omega0 ^ a) 0 | true |
Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Sort u → Lean.Meta.Grind.Arith.Cutsat.SymbolicBound → Lean.Meta.Grind.Arith.Cutsat.SymbolicBound → Sort u | false |
CategoryTheory.Abelian.extFunctor._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) {X₁ X₂ : Cᵒᵖ} (f : X₁ ⟶ X₂) {Y₁ Y₂ : C} (g : Y₁ ⟶ Y₂),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Abelian.extFunctorObj (Opposite.unop X₁) n).map g)
(AddCommGrpCat.ofHom (AddMonoidHom.mk' (fun α => (CategoryTheory.Abelian.Ext.mk₀ f.unop).comp α ⋯) ⋯)) =
CategoryTheory.CategoryStruct.comp
(AddCommGrpCat.ofHom (AddMonoidHom.mk' (fun α => (CategoryTheory.Abelian.Ext.mk₀ f.unop).comp α ⋯) ⋯))
((CategoryTheory.Abelian.extFunctorObj (Opposite.unop X₂) n).map g) | false |
_private.Mathlib.AlgebraicTopology.DoldKan.Faces.0.AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq._proof_1_8 | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {a : ℕ} (k : ℕ), a + 2 + k = a + k + 1 + 1 | false |
InfTopHom.instMin.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Top α] [inst_2 : SemilatticeInf β] [inst_3 : OrderTop β],
InfTopHom.instMin =
{
min := fun f g =>
have __src := f.toTopHom ⊓ g.toTopHom;
let __SupHom := f.toInfHom ⊓ g.toInfHom;
{ toInfHom := __SupHom, map_top' := ⋯ } } | true |
Std.DHashMap.Const.Equiv.beq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : BEq β]
[EquivBEq α] [LawfulHashable α] [ReflBEq β], m₁.Equiv m₂ → Std.DHashMap.Const.beq m₁ m₂ = true | true |
Monoid.CoprodI.NeWord.singleton | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → Monoid (M i)] → {i : ι} → (x : M i) → x ≠ 1 → Monoid.CoprodI.NeWord M i i | true |
Lean.Parser.Command.grindPattern._regBuiltin.Lean.Parser.Command.GrindCnstr.guard.formatter_43 | Lean.Meta.Tactic.Grind.Parser | IO Unit | false |
EuclideanGeometry.Sphere.isTangentAt_iff_dist_sq_eq_power | Mathlib.Geometry.Euclidean.Sphere.Power | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {P : Type u_2} [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {t p : P} {s : EuclideanGeometry.Sphere P},
t ∈ s → (s.IsTangentAt t (affineSpan ℝ {p, t}) ↔ dist p t ^ 2 = s.power p) | true |
_private.Mathlib.Algebra.Order.Monoid.Canonical.Basic.0.exists_lt_add_iff_lt_left._simp_1_1 | Mathlib.Algebra.Order.Monoid.Canonical.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α} [inst_1 : Add α] [CanonicallyOrderedAdd α] [AddLeftReflectLT α]
[IsLeftCancelAdd α], (a < b + c) = (a < b ∨ ∃ d < c, a = b + d) | false |
Filter.EventuallyEq.gradient | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x : F} {f₁ : F → 𝕜}, f₁ =ᶠ[nhds x] f → gradient f₁ =ᶠ[nhds x] gradient f | true |
FormalMultilinearSeries.rightInv._proof_33 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
spectrum.of_subsingleton | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] [Subsingleton A] (a : A),
spectrum R a = ∅ | true |
Finset.subset_image_iff | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β},
t ⊆ Finset.image f s ↔ ∃ s' ⊆ s, Finset.image f s' = t | true |
LinearEquiv.ofFinrankEq.congr_simp | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} (M : Type v) (M' : Type v') [inst : Semiring R] [inst_1 : StrongRankCondition R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module.Free R M] [inst_5 : AddCommMonoid M']
[inst_6 : Module R M'] [inst_7 : Module.Free R M'] [inst_8 : Module.Finite R M] [inst_9 : Module.Finite R M']
(cond : Module.finrank R M = Module.finrank R M'),
LinearEquiv.ofFinrankEq M M' cond = LinearEquiv.ofFinrankEq M M' cond | true |
Array.getElem?_setIfInBounds_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α}, (xs.setIfInBounds i a)[i]? = if i < xs.size then some a else none | true |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.«_aux_Mathlib_Algebra_Order_Antidiag_Pi___macroRules__private_Mathlib_Algebra_Order_Antidiag_Pi_0_Finset_term_•ℕ__1» | Mathlib.Algebra.Order.Antidiag.Pi | Lean.Macro | false |
_private.Std.Data.ByteSlice.0.ByteSlice.size_le_size_byteArray._simp_1_4 | Std.Data.ByteSlice | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
RestrictedProduct.instCommGroupCoeOfSubgroupClass._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → CommGroup (R i)] [∀ (i : ι), SubgroupClass (S i) (R i)] (i : ι), MulMemClass (S i) (R i) | false |
Lean.Parser.Term.nofun._regBuiltin.Lean.Parser.Term.nofun_1 | Lean.Parser.Term | IO Unit | false |
AlgebraicGeometry.IsOpenImmersion.lift_fac | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [H : AlgebraicGeometry.IsOpenImmersion f]
(H' : Set.range ⇑g ⊆ Set.range ⇑f),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsOpenImmersion.lift f g H') f = g | true |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x :
{ h // ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp h (f j₁) = CategoryTheory.CategoryStruct.comp h (f j₂) })
(j₁ j₂ : J),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑x ⋯)) t.ι) (f j₁) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑x ⋯)) t.ι) (f j₂) | false |
Std.DTreeMap.getKeyLED | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → α → α | true |
Filter.EventuallyEq.iInter | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Sort x} {l : Filter α} [Finite ι] {s t : ι → Set α},
(∀ (i : ι), s i =ᶠ[l] t i) → ⋂ i, s i =ᶠ[l] ⋂ i, t i | true |
IntermediateField.restrictScalars_eq_top_iff._simp_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
[inst_3 : Field K] [inst_4 : Algebra K E] [inst_5 : Algebra K F] [inst_6 : IsScalarTower K F E]
{L : IntermediateField F E}, (IntermediateField.restrictScalars K L = ⊤) = (L = ⊤) | false |
AddSubmonoid.toSubmonoid_closure | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {A : Type u_4} [inst : AddZeroClass A] (S : Set A),
AddSubmonoid.toSubmonoid (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.toAdd ⁻¹' S) | true |
CategoryTheory.ObjectProperty.epiModSerre | Mathlib.CategoryTheory.Abelian.SerreClass.MorphismProperty | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
(P : CategoryTheory.ObjectProperty C) → [P.IsSerreClass] → CategoryTheory.MorphismProperty C | true |
PolynomialModule.comp_eval | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) ((PolynomialModule.comp p) q) = (PolynomialModule.eval (Polynomial.eval r p)) q | true |
Turing.TM2to1.trStAct | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
[DecidableEq K] →
{k : K} →
Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ) σ →
Turing.TM2to1.StAct K Γ σ k → Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ) σ | true |
Cardinal.aleph0_le_mul_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (Cardinal.aleph0 ≤ a ∨ Cardinal.aleph0 ≤ b) | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensor._proof_1 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
CategoryTheory.Limits.HasPushout
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.residueFieldCongr ⋯).inv
(AlgebraicGeometry.Scheme.Hom.residueFieldMap f T.x))
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.residueFieldCongr ⋯).inv
(AlgebraicGeometry.Scheme.Hom.residueFieldMap g T.y)) | false |
AddSubmonoid.multiples_fg | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] (r : M), (AddSubmonoid.multiples r).FG | true |
Lean.Meta.Grind.ParentSet.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.ParentSet → Sort u} →
(t : Lean.Meta.Grind.ParentSet) → ((parents : List Lean.Expr) → motive { parents := parents }) → motive t | false |
_private.Mathlib.Analysis.Calculus.LocalExtr.Rolle.0.exists_hasDerivAt_eq_zero.match_1_1 | Mathlib.Analysis.Calculus.LocalExtr.Rolle | ∀ {f : ℝ → ℝ} {a b : ℝ} (motive : (∃ c ∈ Set.Ioo a b, IsLocalExtr f c) → Prop) (x : ∃ c ∈ Set.Ioo a b, IsLocalExtr f c),
(∀ (c : ℝ) (cmem : c ∈ Set.Ioo a b) (hc : IsLocalExtr f c), motive ⋯) → motive x | false |
Mathlib.Tactic.GCongr.GCongrKey._sizeOf_1 | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrKey → ℕ | false |
tensorIteratedFDerivTwo | Mathlib.Analysis.InnerProductSpace.Laplacian | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → (E → F) → E → TensorProduct 𝕜 E E →ₗ[𝕜] F | true |
String.containsSubstr | Batteries.Data.String.Matcher | String → Substring.Raw → Bool | true |
retractionOfSectionOfKerSqZero._proof_2 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : Algebra R P], SMulCommClass R P P | false |
AddValuation.map_le_sum | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{ι : Type u_6} {s : Finset ι} {f : ι → R} {g : Γ₀}, (∀ i ∈ s, g ≤ v (f i)) → g ≤ v (∑ i ∈ s, f i) | true |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.ev_app | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalClosed V] →
{F G H : CategoryTheory.Functor C V} →
[inst_5 : CategoryTheory.MonoidalCategory.DayConvolution F H] →
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom F G H →
(CategoryTheory.MonoidalCategory.DayConvolution.convolution F H ⟶ G) | true |
Filter.subsingleton_bot | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1}, ⊥.Subsingleton | true |
CategoryTheory.PrelaxFunctor.map₂_inv_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (η : f ≅ g) {Z : F.obj a ⟶ F.obj b} (h : F.map g ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map₂ η.inv) (CategoryTheory.CategoryStruct.comp (F.map₂ η.hom) h) = h | true |
RingCat.Colimits.quot_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat),
Quot.mk (⇑(RingCat.Colimits.colimitSetoid F)) RingCat.Colimits.Prequotient.zero = 0 | true |
CategoryTheory.Limits.biproduct.isLimitFromSubtype._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) (i : J)
[inst_2 : CategoryTheory.Limits.HasBiproduct f]
[inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)]
(s : CategoryTheory.Limits.Fork (CategoryTheory.Limits.biproduct.π f i) 0),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp s.ι (CategoryTheory.Limits.biproduct.toSubtype f fun j => j ≠ i))
(CategoryTheory.Limits.Fork.ι
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.biproduct.fromSubtype f fun j => j ≠ i) ⋯)) =
s.ι | false |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.totalShift₁XIso._proof_3 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (x n n' : ℤ), n + x = n' → ∀ (p q : ℤ), p + q = n' → p - x + q = n | false |
Int.add_mul_modulus_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a + b * n ≡ c [ZMOD n] ↔ a ≡ c [ZMOD n] | true |
Lean.MonadLog.recOn | Lean.Log | {m : Type → Type} →
{motive : Lean.MonadLog m → Sort u} →
(t : Lean.MonadLog m) →
([toMonadFileMap : Lean.MonadFileMap m] →
(getRef : m Lean.Syntax) →
(getFileName : m String) →
(hasErrors : m Bool) →
(logMessage : Lean.Message → m Unit) →
motive
{ toMonadFileMap := toMonadFileMap, getRef := getRef, getFileName := getFileName,
hasErrors := hasErrors, logMessage := logMessage }) →
motive t | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.abs_eval_T_real_eq_one_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.isUniformInducing_ofLp_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], IsUniformInducing WithLp.ofLp | true |
CategoryTheory.Bicategory.rec | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
{motive : CategoryTheory.Bicategory B → Sort u_1} →
([toCategoryStruct : CategoryTheory.CategoryStruct.{v, u} B] →
(homCategory : (a b : B) → CategoryTheory.Category.{w, v} (a ⟶ b)) →
(whiskerLeft :
{a b c : B} →
(f : a ⟶ b) →
{g h : b ⟶ c} →
(g ⟶ h) → (CategoryTheory.CategoryStruct.comp f g ⟶ CategoryTheory.CategoryStruct.comp f h)) →
(whiskerRight :
{a b c : B} →
{f g : a ⟶ b} →
(f ⟶ g) →
(h : b ⟶ c) → CategoryTheory.CategoryStruct.comp f h ⟶ CategoryTheory.CategoryStruct.comp g h) →
(associator :
{a b c d : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
(h : c ⟶ d) →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h ≅
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h)) →
(leftUnitor :
{a b : B} →
(f : a ⟶ b) → CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f ≅ f) →
(rightUnitor :
{a b : B} →
(f : a ⟶ b) → CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id b) ≅ f) →
(whiskerLeft_id :
∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
whiskerLeft f (CategoryTheory.CategoryStruct.id g) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g)) →
(whiskerLeft_comp :
∀ {a b c : B} (f : a ⟶ b) {g h i : b ⟶ c} (η : g ⟶ h) (θ : h ⟶ i),
whiskerLeft f (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp (whiskerLeft f η) (whiskerLeft f θ)) →
(id_whiskerLeft :
∀ {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
whiskerLeft (CategoryTheory.CategoryStruct.id a) η =
CategoryTheory.CategoryStruct.comp (leftUnitor f).hom
(CategoryTheory.CategoryStruct.comp η (leftUnitor g).inv)) →
(comp_whiskerLeft :
∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) {h h' : c ⟶ d} (η : h ⟶ h'),
whiskerLeft (CategoryTheory.CategoryStruct.comp f g) η =
CategoryTheory.CategoryStruct.comp (associator f g h).hom
(CategoryTheory.CategoryStruct.comp (whiskerLeft f (whiskerLeft g η))
(associator f g h').inv)) →
(id_whiskerRight :
∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
whiskerRight (CategoryTheory.CategoryStruct.id f) g =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g)) →
(comp_whiskerRight :
∀ {a b c : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h) (i : b ⟶ c),
whiskerRight (CategoryTheory.CategoryStruct.comp η θ) i =
CategoryTheory.CategoryStruct.comp (whiskerRight η i) (whiskerRight θ i)) →
(whiskerRight_id :
∀ {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
whiskerRight η (CategoryTheory.CategoryStruct.id b) =
CategoryTheory.CategoryStruct.comp (rightUnitor f).hom
(CategoryTheory.CategoryStruct.comp η (rightUnitor g).inv)) →
(whiskerRight_comp :
∀ {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d),
whiskerRight η (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (associator f g h).inv
(CategoryTheory.CategoryStruct.comp (whiskerRight (whiskerRight η g) h)
(associator f' g h).hom)) →
(whisker_assoc :
∀ {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d),
whiskerRight (whiskerLeft f η) h =
CategoryTheory.CategoryStruct.comp (associator f g h).hom
(CategoryTheory.CategoryStruct.comp (whiskerLeft f (whiskerRight η h))
(associator f g' h).inv)) →
(whisker_exchange :
∀ {a b c : B} {f g : a ⟶ b} {h i : b ⟶ c} (η : f ⟶ g) (θ : h ⟶ i),
CategoryTheory.CategoryStruct.comp (whiskerLeft f θ) (whiskerRight η i) =
CategoryTheory.CategoryStruct.comp (whiskerRight η h) (whiskerLeft g θ)) →
(pentagon :
∀ {a b c d e : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) (i : d ⟶ e),
CategoryTheory.CategoryStruct.comp (whiskerRight (associator f g h).hom i)
(CategoryTheory.CategoryStruct.comp
(associator f (CategoryTheory.CategoryStruct.comp g h) i).hom
(whiskerLeft f (associator g h i).hom)) =
CategoryTheory.CategoryStruct.comp
(associator (CategoryTheory.CategoryStruct.comp f g) h i).hom
(associator f g (CategoryTheory.CategoryStruct.comp h i)).hom) →
(triangle :
∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(associator f (CategoryTheory.CategoryStruct.id b) g).hom
(whiskerLeft f (leftUnitor g).hom) =
whiskerRight (rightUnitor f).hom g) →
motive
{ toCategoryStruct := toCategoryStruct, homCategory := homCategory,
whiskerLeft := whiskerLeft, whiskerRight := whiskerRight,
associator := associator, leftUnitor := leftUnitor,
rightUnitor := rightUnitor, whiskerLeft_id := whiskerLeft_id,
whiskerLeft_comp := whiskerLeft_comp, id_whiskerLeft := id_whiskerLeft,
comp_whiskerLeft := comp_whiskerLeft,
id_whiskerRight := id_whiskerRight,
comp_whiskerRight := comp_whiskerRight,
whiskerRight_id := whiskerRight_id,
whiskerRight_comp := whiskerRight_comp, whisker_assoc := whisker_assoc,
whisker_exchange := whisker_exchange, pentagon := pentagon,
triangle := triangle }) →
(t : CategoryTheory.Bicategory B) → motive t | false |
ContinuousLinearMap.norm_iteratedFDerivWithin_comp_left | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (L : F →L[𝕜] G) {f : E → F} {s : Set E} {x : E}
{N : WithTop ℕ∞} {n : ℕ},
ContDiffWithinAt 𝕜 N f s x →
UniqueDiffOn 𝕜 s → x ∈ s → ↑n ≤ N → ‖iteratedFDerivWithin 𝕜 n (⇑L ∘ f) s x‖ ≤ ‖L‖ * ‖iteratedFDerivWithin 𝕜 n f s x‖ | true |
Std.DTreeMap.Internal.Impl.balanceₘ._proof_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.leaf.size > Std.DTreeMap.Internal.delta * l.size → False | false |
Set.PartiallyWellOrderedOn.subsetProdLex | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] {s : Set (Lex (α × β))},
((fun x => (ofLex x).1) '' s).IsPWO → (∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO) → s.IsPWO | true |
ProbabilityTheory.IsRatCondKernelCDFAux.integrable | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ (a : α) (q : ℚ), MeasureTheory.Integrable (fun c => f (a, c) q) (ν a) | true |
HomologicalComplex.pOpcyclesIso | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {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 j : ι) → c.prev j = i → K.d i j = 0 → [inst_2 : K.HasHomology j] → K.X j ≅ K.opcycles j | true |
NonUnitalStarSubalgebra.toStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : StarRing A]
[inst_3 : Algebra R A] (S : NonUnitalStarSubalgebra R A) {a b : A}, a ∈ S.carrier → b ∈ S.carrier → a * b ∈ S.carrier | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.hausdorffDist_zero_iff_closure_eq_closure._simp_1_3 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.