name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Cardinal.Real.Icc_countable_iff._simp_1 | Mathlib.Analysis.Real.Cardinality | ∀ {x y : ℝ}, (Set.Icc x y).Countable = (y ≤ x) | false |
AlgebraicGeometry.IsDominant | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | true |
Lean.MessageData.TraceResult.success.elim | Mathlib.Lean.MessageData.Trace | {motive : Lean.MessageData.TraceResult → Sort u} →
(t : Lean.MessageData.TraceResult) → t.ctorIdx = 0 → motive Lean.MessageData.TraceResult.success → motive t | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.min_apply | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {e₁ e₂ : (a : α) × β a} {f : (a : α) × β a → (a : α) × β a},
compare e₁.fst e₂.fst = compare (f e₁).fst (f e₂).fst → f e₁ ⊓ f e₂ = f (e₁ ⊓ e₂) | true |
_private.Lean.Compiler.Specialize.0.Lean.Compiler.elabSpecArgs._proof_4 | Lean.Compiler.Specialize | ∀ (argNames : Array Lean.Name) (idx : ℕ), ¬idx - 1 ≥ argNames.size → ¬idx - 1 < argNames.size → False | false |
_private.Lean.Server.Watchdog.0.Lean.Server.Watchdog.emitServerRequestResponse.match_1 | Lean.Server.Watchdog | (motive : Lean.Server.Watchdog.WorkerState → Sort u_1) →
(__do_lift : Lean.Server.Watchdog.WorkerState) →
(Unit → motive Lean.Server.Watchdog.WorkerState.running) →
((x : Lean.Server.Watchdog.WorkerState) → motive x) → motive __do_lift | false |
Lean.ModuleArtifacts._sizeOf_1 | Lean.Setup | Lean.ModuleArtifacts → ℕ | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertListIfNewUnit.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] (l : List ((_ : α) × Unit)) (hd : α) (tl : List α),
Std.Internal.List.insertListIfNewUnit l (hd :: tl) =
Std.Internal.List.insertListIfNewUnit (Std.Internal.List.insertEntryIfNew hd () l) tl | true |
Complex.hasStrictDerivAt_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (x : ℂ), HasStrictDerivAt Complex.sinh (Complex.cosh x) x | true |
CategoryTheory.Subfunctor.lift_app_coe | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (f : F' ⟶ F)
{G : CategoryTheory.Subfunctor F} (hf : CategoryTheory.Subfunctor.range f ≤ G) (U : C) (x : F'.obj U),
↑((CategoryTheory.Subfunctor.lift f hf).app U x) = f.app U x | true |
Std.DTreeMap.Const.get?_congr | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {a b : α},
cmp a b = Ordering.eq → Std.DTreeMap.Const.get? t a = Std.DTreeMap.Const.get? t b | true |
completeSpace_congr | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {e : α ≃ β},
IsUniformEmbedding ⇑e → (CompleteSpace α ↔ CompleteSpace β) | true |
String.Pos.Raw.IsValidForSlice.ofSlice | Init.Data.String.Basic | ∀ {s : String} {p : String.Pos.Raw}, String.Pos.Raw.IsValidForSlice s.toSlice p → String.Pos.Raw.IsValid s p | true |
Sigma.instLocallyFiniteOrder._proof_4 | Mathlib.Data.Sigma.Interval | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Preorder (α i)]
[inst_2 : (i : ι) → LocallyFiniteOrder (α i)] (x x_1 x_2 : (i : ι) × α i),
x_2 ∈ Finset.sigmaLift (fun x => Finset.Ioo) x x_1 ↔ x < x_2 ∧ x_2 < x_1 | false |
Std.DTreeMap.Internal.Impl.Const.beq.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : BEq β] (t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.beq t₁ t₂ =
if t₁.size ≠ t₂.size then false else t₁.all fun k v => Std.DTreeMap.Internal.Impl.Const.get? t₂ k == some v | true |
SSet.RelativeMorphism.image_le | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} (f : SSet.RelativeMorphism A B φ),
A.image f.map ≤ B | true |
Field.ofMinimalAxioms._proof_2 | Mathlib.Algebra.Field.MinimalAxioms | ∀ (K : Type u_1) [inst : Add K] [inst_1 : Mul K] [inst_2 : Neg K] [inst_3 : Inv K] [inst_4 : Zero K] [inst_5 : One K]
(add_assoc : ∀ (a b c : K), a + b + c = a + (b + c)) (zero_add : ∀ (a : K), 0 + a = a)
(neg_add_cancel : ∀ (a : K), -a + a = 0) (mul_assoc : ∀ (a b c : K), a * b * c = a * (b * c))
(mul_comm : ∀ (a b : K), a * b = b * a) (one_mul : ∀ (a : K), 1 * a = a)
(left_distrib : ∀ (a b c : K), a * (b + c) = a * b + a * c) (a : K), zpowRec npowRec 0 a = 1 | false |
Commute.cfcₙ_nnreal | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Commute | ∀ {A : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : Module ℝ A] [inst_3 : IsScalarTower ℝ A A]
[inst_4 : SMulCommClass ℝ A A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [IsTopologicalRing A] [T2Space A]
[inst_9 : PartialOrder A] [inst_10 : NonnegSpectrumClass ℝ A] [inst_11 : StarOrderedRing A] {a b : A},
Commute a b → ∀ (f : NNReal → NNReal), Commute (cfcₙ f a) b | true |
_private.Mathlib.FieldTheory.Isaacs.0.Field.nonempty_algHom_of_exists_root.match_1_3 | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_2} {E : Type u_3} {K : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] (α : E) (motive : (∃ y, (Polynomial.aeval y) (minpoly F α) = 0) → Prop)
(x : ∃ y, (Polynomial.aeval y) (minpoly F α) = 0),
(∀ (β : K) (hβ : (Polynomial.aeval β) (minpoly F α) = 0), motive ⋯) → motive x | false |
Lean.Server.Watchdog.ModuleQueryMatchScore.casesOn | Lean.Server.Watchdog | {motive : Lean.Server.Watchdog.ModuleQueryMatchScore → Sort u} →
(t : Lean.Server.Watchdog.ModuleQueryMatchScore) →
((isExactMatch : Bool) → (score : Float) → motive { isExactMatch := isExactMatch, score := score }) → motive t | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.mem_rootsOfUnity_prime_pow_mul_iff._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (↑ζ ^ k = 1) | false |
CategoryTheory.MonoOver.isoMk_hom | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {f g : CategoryTheory.MonoOver X}
(h : f.obj.left ≅ g.obj.left)
(w : autoParam (CategoryTheory.CategoryStruct.comp h.hom g.arrow = f.arrow) CategoryTheory.MonoOver.isoMk._auto_1),
(CategoryTheory.MonoOver.isoMk h w).hom = CategoryTheory.MonoOver.homMk h.hom w | true |
AlgebraicGeometry.Scheme.RationalMap.toPartialMap._proof_6 | Mathlib.AlgebraicGeometry.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] [Y.IsSeparated] (f : X.RationalMap Y)
(x y : f.openCoverDomain.I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (f.openCoverDomain.f x) (f.openCoverDomain.f y))
(CategoryTheory.CategoryStruct.comp (X.isoOfEq ⋯).inv (Exists.choose ⋯).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd (f.openCoverDomain.f x) (f.openCoverDomain.f y))
(CategoryTheory.CategoryStruct.comp (X.isoOfEq ⋯).inv (Exists.choose ⋯).hom) | false |
commBialgCatEquivComonCommAlgCat._proof_9 | Mathlib.Algebra.Category.CommBialgCat | ∀ (R : Type u_1) [inst : CommRing R],
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CommBialgCat R)))
(CategoryTheory.CategoryStruct.id
({ obj := fun A => Opposite.op { X := Opposite.op (CommAlgCat.of R ↑A), mon := CommAlgCat.monObjOpOf },
map := fun {A B} f =>
Quiver.Hom.op (CategoryTheory.Mon.Hom.mk' (CommAlgCat.ofHom ↑(CommBialgCat.Hom.hom f)).op ⋯ ⋯),
map_id := ⋯, map_comp := ⋯ }.comp
{ obj := fun A => CommBialgCat.of R ↑(Opposite.unop (Opposite.unop A).X),
map := fun {A B} f => CommBialgCat.ofHom (BialgHom.ofAlgHom (CommAlgCat.Hom.hom f.unop.hom.unop) ⋯ ⋯),
map_id := ⋯, map_comp := ⋯ })) =
CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CommBialgCat R)) | false |
Matrix.toLinearEquivRight'OfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : Semiring R] {m : Type u_3} {n : Type u_2} [inst_1 : Fintype m] [inst_2 : DecidableEq m]
[inst_3 : Fintype n] [inst_4 : DecidableEq n] {M : Matrix m n R} {M' : Matrix n m R},
M' * M = 1 → ∀ (x : n → R), (Matrix.toLinearMapRight' M) ((Matrix.toLinearMapRight' M') x) = x | false |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.sup._proof_3 | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{u_1}} [Fact κ.IsRegular]
(D₁ D₂ : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ), (D₁.W ⊔ D₂.W).HasCardinalLT κ | false |
Function.ExtendByZero.linearMap | Mathlib.LinearAlgebra.Pi | (R : Type u) → {ι : Type x} → {η : Type u_1} → [inst : Semiring R] → (ι → η) → (ι → R) →ₗ[R] η → R | true |
Std.Internal.List.isEmpty_filter_eq_true | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {f : (a : α) → β a → Bool}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
((List.filter (fun p => f p.fst p.snd) l).isEmpty = true ↔
∀ (k : α) (h : Std.Internal.List.containsKey k l = true), f k (Std.Internal.List.getValueCast k l h) = false) | true |
ModuleCat.preservesColimit_restrictScalars | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {J : Type u_3}
[inst_2 : CategoryTheory.Category.{v_1, u_3} J] (F : CategoryTheory.Functor J (ModuleCat S))
[CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat S) AddCommGrpCat))],
CategoryTheory.Limits.PreservesColimit F (ModuleCat.restrictScalars f) | true |
CategoryTheory.Limits.limitFlipIsoCompLim._proof_3 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] {K : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} K]
[CategoryTheory.Limits.HasLimitsOfShape J C] (F : CategoryTheory.Functor K (CategoryTheory.Functor J C)) (k : K),
CategoryTheory.Limits.HasLimit (F.obj k) | false |
ContMDiff.cle_arrowCongr | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F₁ : Type u_8} [inst_6 : NormedAddCommGroup F₁]
[inst_7 : NormedSpace 𝕜 F₁] {F₂ : Type u_9} [inst_8 : NormedAddCommGroup F₂] [inst_9 : NormedSpace 𝕜 F₂]
{F₃ : Type u_10} [inst_10 : NormedAddCommGroup F₃] [inst_11 : NormedSpace 𝕜 F₃] {F₄ : Type u_11}
[inst_12 : NormedAddCommGroup F₄] [inst_13 : NormedSpace 𝕜 F₄] {n : WithTop ℕ∞} {f : M → F₁ ≃L[𝕜] F₂}
{g : M → F₃ ≃L[𝕜] F₄},
(ContMDiff I (modelWithCornersSelf 𝕜 (F₂ →L[𝕜] F₁)) n fun x => ↑(f x).symm) →
(ContMDiff I (modelWithCornersSelf 𝕜 (F₃ →L[𝕜] F₄)) n fun x => ↑(g x)) →
ContMDiff I (modelWithCornersSelf 𝕜 ((F₁ →L[𝕜] F₃) →L[𝕜] F₂ →L[𝕜] F₄)) n fun y => ↑((f y).arrowCongr (g y)) | true |
CategoryTheory.IsCardinalLocallyPresentable.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.LocallyPresentable | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
autoParam (∀ (X Y : C), Small.{w, v} (X ⟶ Y)) CategoryTheory.LocallySmall.hom_small._autoParam →
(∃ P, ∃ (_ : CategoryTheory.ObjectProperty.EssentiallySmall.{w, v, u} P), P.IsCardinalFilteredGenerator κ) →
autoParam
(∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w, w} J], CategoryTheory.Limits.HasColimitsOfShape J C)
CategoryTheory.Limits.HasColimitsOfSize.has_colimits_of_shape._autoParam →
CategoryTheory.IsCardinalLocallyPresentable C κ | false |
Nat.add_le_add_iff_right._simp_1 | Init.Data.Nat.Basic | ∀ {m k n : ℕ}, (m + n ≤ k + n) = (m ≤ k) | false |
pointedToTwoPSnd._proof_3 | Mathlib.CategoryTheory.Category.TwoP | ∀ {X Y Z : Pointed} (f : X ⟶ Y) (g : Y ⟶ Z),
{ hom := { toFun := Option.map (CategoryTheory.CategoryStruct.comp f g).toFun, map_fst := ⋯, map_snd := ⋯ } } =
CategoryTheory.CategoryStruct.comp { hom := { toFun := Option.map f.toFun, map_fst := ⋯, map_snd := ⋯ } }
{ hom := { toFun := Option.map g.toFun, map_fst := ⋯, map_snd := ⋯ } } | false |
Std.Do.ExceptConds.entails_true._simp_1 | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {x : Std.Do.ExceptConds ps}, x.entails Std.Do.ExceptConds.true = True | false |
ExistsAndEq.withNestedExistsIntro | Mathlib.Tactic.Simproc.ExistsAndEq | {P body : Q(Prop)} → List ExistsAndEq.VarQ → Lean.MetaM Q(«$body») → Lean.MetaM Q(«$P») | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.auxContinuousLinearEquiv._proof_12 | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {𝕜 : Type u_3} {V : Type u_2} {W : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] [inst_4 : NormedAddCommGroup W]
[inst_5 : InnerProductSpace 𝕜 W] [inst_6 : CompleteSpace W] (e : V ≃L[𝕜] W) {α' : 𝕜},
Continuous ⇑(α' • ContinuousLinearMap.adjoint ↑e) | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint.match_1.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(motive : Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → Sort u_1)
(h_1 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth)
(h_2 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty)
(h_3 :
(l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
(b : Bool) → motive (Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b)))
(h_4 : Unit → motive Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit),
(match Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth with
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth => h_1 ()
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty => h_2 ()
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit (l, b) => h_3 l b
| Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToNonunit => h_4 ()) =
h_1 () | true |
Float.toRatParts | Batteries.Lean.Float | Float → Option (ℤ × ℤ) | true |
Std.DHashMap.Raw.getKey_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (not_mem : k ∉ m₂)
{h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).getKey k h' = m₁.getKey k ⋯ | true |
Representation.asAlgebraHom_of | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (g : G), ρ.asAlgebraHom ((MonoidAlgebra.of k G) g) = ρ g | true |
Std.TreeMap.Raw.maxKeyD_le | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
t.isEmpty = false → ∀ {k fallback : α}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | true |
Std.Packages.PreorderOfLEArgs._sizeOf_1 | Init.Data.Order.PackageFactories | {α : Type u} → [SizeOf α] → Std.Packages.PreorderOfLEArgs α → ℕ | false |
commutatorElement_one_left | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : Group G] (g : G), ⁅1, g⁆ = 1 | true |
ProbabilityTheory.variance_sum_pi | Mathlib.Probability.Moments.Variance | ∀ {ι : Type u_2} [inst : Fintype ι] {Ω : ι → Type u_3} {mΩ : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{X : (i : ι) → Ω i → ℝ},
(∀ (i : ι), MeasureTheory.MemLp (X i) 2 (μ i)) →
ProbabilityTheory.variance (∑ i, fun ω => X i (ω i)) (MeasureTheory.Measure.pi μ) =
∑ i, ProbabilityTheory.variance (X i) (μ i) | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.AntitoneOn.integral_le_sum._simp_1_6 | Mathlib.Analysis.SumIntegralComparisons | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
MeasureTheory.Measure.compProd_eq_comp_prod | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : MeasureTheory.Measure α)
[MeasureTheory.SFinite μ] (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ],
μ.compProd κ = μ.bind ⇑(ProbabilityTheory.Kernel.id.prod κ) | true |
MeasureTheory.integral_conv | Mathlib.MeasureTheory.Group.IntegralConvolution | ∀ {M : Type u_1} {F : Type u_2} [inst : AddMonoid M] {mM : MeasurableSpace M} [MeasurableAdd₂ M]
[inst_2 : NormedAddCommGroup F] {μ ν : MeasureTheory.Measure M} {f : M → F} [inst_3 : NormedSpace ℝ F]
[MeasureTheory.SFinite μ] [MeasureTheory.SFinite ν],
MeasureTheory.Integrable f (μ.conv ν) → ∫ (x : M), f x ∂μ.conv ν = ∫ (x : M), ∫ (y : M), f (x + y) ∂ν ∂μ | true |
CategoryTheory.Limits.limit.cone_x | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F],
(CategoryTheory.Limits.limit.cone F).pt = CategoryTheory.Limits.limit F | true |
LineDeriv.«_aux_Mathlib_Analysis_Distribution_DerivNotation___macroRules_LineDeriv_term∂_{_}_1» | Mathlib.Analysis.Distribution.DerivNotation | Lean.Macro | false |
Pi.isCompact_iff_of_isClosed | Mathlib.Topology.Compactness.Compact | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {s : Set ((i : ι) → X i)},
IsClosed s → (IsCompact s ↔ ∀ (i : ι), IsCompact (Function.eval i '' s)) | true |
TemperedDistribution.instFourierTransformInv | Mathlib.Analysis.Distribution.TemperedDistribution | {E : Type u_3} →
{F : Type u_4} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : InnerProductSpace ℝ E] →
[inst_3 : NormedSpace ℂ F] →
[FiniteDimensional ℝ E] →
[inst_5 : MeasurableSpace E] →
[BorelSpace E] → FourierTransformInv (TemperedDistribution E F) (TemperedDistribution E F) | true |
Subgroup.zpowers_one_eq_bot | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ {G : Type u_1} [inst : Group G], Subgroup.zpowers 1 = ⊥ | true |
_private.Lean.Elab.Tactic.Conv.Pattern.0.Lean.Elab.Tactic.Conv.evalPattern.match_5 | Lean.Elab.Tactic.Conv.Pattern | (motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u_1) →
(occs : Lean.Elab.Tactic.Conv.PatternMatchState) →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((x : Lean.Elab.Tactic.Conv.PatternMatchState) → motive x) → motive occs | false |
AlgebraicGeometry.Scheme.Modules.instCategory._proof_2 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {X_1 Y : SheafOfModules X.ringCatSheaf} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f | false |
DividedPowers.ofInjective._proof_2 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B),
Function.Injective ⇑f →
∀ (hJ : DividedPowers J),
Ideal.map f I = J →
∀ (hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {x : A},
x ∈ I → (if hx : x ∈ I then ⋯.choose else 0) = 1 | false |
WeierstrassCurve.Jacobian.addXYZ.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P Q : Fin 3 → R),
W'.addXYZ P Q = ![W'.addX P Q, W'.addY P Q, WeierstrassCurve.Jacobian.addZ P Q] | true |
Lean.Elab.Do.elabDoElem._unsafe_rec | Lean.Elab.Do.Basic | Lean.TSyntax `doElem → Lean.Elab.Do.DoElemCont → optParam Bool true → Lean.Elab.Do.DoElabM Lean.Expr | false |
ClosedIciTopology | Mathlib.Topology.Order.OrderClosed | (α : Type u_1) → [TopologicalSpace α] → [Preorder α] → Prop | true |
_private.Mathlib.RingTheory.Valuation.RankOne.0.Valuation.RankLeOne.exists_val_lt._simp_1_1 | Mathlib.RingTheory.Valuation.RankOne | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | false |
QuadraticMap.Nondegenerate.rank_rad_polar_le | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {R : Type u_1} {M : Type u_2} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup P] [inst_2 : CommRing R]
[inst_3 : Module R M] [inst_4 : Module R P] {Q : QuadraticMap R M P},
QuadraticMap.Nondegenerate → Module.rank R ↥(LinearMap.ker Q.polarBilin) ≤ 1 | true |
OrderDual.instLocallyFiniteOrderTop._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (x x_1 : αᵒᵈ),
x_1 ∈ Finset.Iic (OrderDual.ofDual x) ↔ x_1 ≤ OrderDual.ofDual x | false |
CategoryTheory.SmallObject.locallySmall | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [I.IsCardinalForSmallObjectArgument κ],
CategoryTheory.LocallySmall.{w, v, u} C | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_5.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (ls : ℕ) (lk : α) (lv : β lk)
(ll lr : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.Impl α β) → motive (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr)),
(match Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr with
| Std.DTreeMap.Internal.Impl.leaf => h_1 ()
| Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr => h_2 ls lk lv ll lr) =
h_2 ls lk lv ll lr | true |
SimpleGraph.componentComplMk_eq_of_adj | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | ∀ {V : Type u} {K : Set V} (G : SimpleGraph V) {v w : V} (vK : v ∉ K) (wK : w ∉ K),
G.Adj v w → G.componentComplMk vK = G.componentComplMk wK | true |
CategoryTheory.Functor.CoconeTypes.mk.injEq | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (pt : Type w₁)
(ι : (j : J) → F.obj j → pt)
(ι_naturality :
autoParam (∀ {j j' : J} (f : j ⟶ j'), ι j' ∘ F.map f = ι j)
CategoryTheory.Functor.CoconeTypes.ι_naturality._autoParam)
(pt_1 : Type w₁) (ι_1 : (j : J) → F.obj j → pt_1)
(ι_naturality_1 :
autoParam (∀ {j j' : J} (f : j ⟶ j'), ι_1 j' ∘ F.map f = ι_1 j)
CategoryTheory.Functor.CoconeTypes.ι_naturality._autoParam),
({ pt := pt, ι := ι, ι_naturality := ι_naturality } = { pt := pt_1, ι := ι_1, ι_naturality := ι_naturality_1 }) =
(pt = pt_1 ∧ ι ≍ ι_1) | true |
List.cons_head!_tail | Mathlib.Data.List.Basic | ∀ {α : Type u} [inst : Inhabited α] {l : List α}, l ≠ [] → l.head! :: l.tail = l | true |
Equiv.linearEquiv._proof_4 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : AddCommMonoid β],
Function.RightInverse e.addEquiv.invFun e.addEquiv.toFun | false |
Profinite.lift_lifts | Mathlib.Topology.Category.Stonean.Basic | ∀ {X Y : Profinite} {Z : Stonean} (e : Stonean.toProfinite.obj Z ⟶ Y) (f : X ⟶ Y) [inst : CategoryTheory.Epi f],
CategoryTheory.CategoryStruct.comp (Profinite.lift e f) f = e | true |
Nat.sqrt_mul_sqrt_lt_succ | Mathlib.Data.Nat.Sqrt | ∀ (n : ℕ), n.sqrt * n.sqrt < n + 1 | true |
_private.Mathlib.GroupTheory.DivisibleHull.0.DivisibleHull.mk_eq_mk_iff_smul_eq_smul._simp_1_2 | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddMonoid M] [IsAddTorsionFree M] {n : ℕ} {a b : M}, n ≠ 0 → (n • a = n • b) = (a = b) | false |
CategoryTheory.ComposableArrows.opEquivalence_inverse_obj | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (n : ℕ) (X : CategoryTheory.ComposableArrows Cᵒᵖ n),
(CategoryTheory.ComposableArrows.opEquivalence C n).inverse.obj X =
Opposite.op
((⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor).comp
(CategoryTheory.Functor.leftOp X)) | true |
Matrix.UnitaryGroup.map_star_inv_eq_transpose | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(U : ↥(Matrix.unitaryGroup n α)), (Matrix.UnitaryGroup.map_star U)⁻¹ = Matrix.UnitaryGroup.transpose U | true |
Set.uIcc_subset_uIcc_iff_le | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ | true |
CategoryTheory.WithTerminal.map | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
CategoryTheory.Functor C D →
CategoryTheory.Functor (CategoryTheory.WithTerminal C) (CategoryTheory.WithTerminal D) | true |
Std.HashMap.emptyWithCapacity_equiv_iff_isEmpty | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{c : ℕ}, (Std.HashMap.emptyWithCapacity c).Equiv m ↔ m.isEmpty = true | true |
Plausible.TestResult.gaveUp.injEq | Plausible.Testable | ∀ {p : Prop} (a a_1 : ℕ), (Plausible.TestResult.gaveUp a = Plausible.TestResult.gaveUp a_1) = (a = a_1) | true |
UniversalEnvelopingAlgebra.ι_comp_lift | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ (R : Type u₁) {L : Type u₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {A : Type u₃}
[inst_3 : Ring A] [inst_4 : Algebra R A] (f : L →ₗ⁅R⁆ A),
⇑((UniversalEnvelopingAlgebra.lift R) f) ∘ ⇑(UniversalEnvelopingAlgebra.ι R) = ⇑f | true |
CategoryTheory.coyonedaEquiv_coyoneda_map | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.coyonedaEquiv (CategoryTheory.coyoneda.map f.op) = f | true |
InnerProductGeometry.mul_norm_eq_abs_sub_sq_norm | Mathlib.Geometry.Euclidean.Sphere.Power | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y z : V},
(∃ k, x = k • y) → ‖z - y‖ = ‖z + y‖ → ‖x - y‖ * ‖x + y‖ = |‖z + y‖ ^ 2 - ‖z - x‖ ^ 2| | true |
Order.Coframe.mk._flat_ctor | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
(le lt : α → α → Prop) →
(le_refl : ∀ (a : α), le a a) →
(le_trans : ∀ (a b c : α), le a b → le b c → le a c) →
(lt_iff_le_not_ge : autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam) →
(le_antisymm : ∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(le_sup_left : ∀ (a b : α), le a (sup a b)) →
(le_sup_right : ∀ (a b : α), le b (sup a b)) →
(sup_le : ∀ (a b c : α), le a c → le b c → le (sup a b) c) →
(inf : α → α → α) →
(∀ (a b : α), le (inf a b) a) →
(∀ (a b : α), le (inf a b) b) →
(∀ (a b c : α), le a b → le a c → le a (inf b c)) →
(sSup : Set α → α) →
(∀ (s : Set α), IsLUB s (sSup s)) →
(sInf : Set α → α) →
(∀ (s : Set α), IsGLB s (sInf s)) →
(top : α) →
(∀ (a : α), le a top) →
(bot : α) →
(∀ (a : α), le bot a) →
(sdiff : α → α → α) →
(∀ (a b c : α), le (sdiff a b) c ↔ le a (b ⊔ c)) →
(hnot : α → α) → (∀ (a : α), sdiff top a = hnot a) → Order.Coframe α | false |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.foldAndCollect.match_10 | Lean.Meta.Tactic.FunInd | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((e1 e2 : Lean.Expr) → motive (e1.app e2)) →
((n : Lean.Name) → (t body : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n t body bi)) →
((n : Lean.Name) → (t body : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.forallE n t body bi)) →
((n : Lean.Name) → (t v b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE n t v b nondep)) →
((m : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata m b)) →
((e : Lean.Expr) → motive (Lean.Expr.proj `PProd 0 e)) →
((e : Lean.Expr) → motive (Lean.Expr.proj `PProd 1 e)) →
((t : Lean.Name) → (i : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj t i e)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((fvar : Lean.FVarId) → motive (Lean.Expr.fvar fvar)) → motive e | false |
Lean.Meta.Grind.Order.ProofInfo.noConfusionType | Lean.Meta.Tactic.Grind.Order.Types | Sort u → Lean.Meta.Grind.Order.ProofInfo → Lean.Meta.Grind.Order.ProofInfo → Sort u | false |
interior_mem_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, interior s ∈ nhds x ↔ s ∈ nhds x | true |
ULift.addZeroClass._proof_2 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_1} [inst : AddZeroClass α], Equiv.ulift 0 = Equiv.ulift 0 | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_inter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Batteries.Tactic.GeneralizeProofs.GState.mk.inj | Batteries.Tactic.GeneralizeProofs | ∀ {propToFVar propToFVar_1 : Lean.ExprMap Lean.Expr},
{ propToFVar := propToFVar } = { propToFVar := propToFVar_1 } → propToFVar = propToFVar_1 | true |
FirstOrder.Language.BoundedFormula.toPrenexImpRight._sparseCasesOn_1 | Mathlib.ModelTheory.Complexity | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
({n : ℕ} → (f₁ f₂ : L.BoundedFormula α n) → motive n (f₁.imp f₂)) →
({n : ℕ} → (f : L.BoundedFormula α (n + 1)) → motive n f.all) →
(Nat.hasNotBit 24 t.ctorIdx → motive a t) → motive a t | false |
_private.Mathlib.Analysis.Complex.Exponential.0.Complex.isCauSeq_norm_exp.match_1_1 | Mathlib.Analysis.Complex.Exponential | ∀ (z : ℂ) (motive : (∃ n, ‖z‖ < ↑n) → Prop) (x : ∃ n, ‖z‖ < ↑n), (∀ (n : ℕ) (hn : ‖z‖ < ↑n), motive ⋯) → motive x | false |
CategoryTheory.functorCategoryPreadditive._proof_9 | Mathlib.CategoryTheory.Preadditive.FunctorCategory | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.Preadditive D]
(F G : CategoryTheory.Functor C D) (a : F ⟶ G), zsmulRec nsmulRec 0 a = 0 | false |
_private.Init.Data.List.MapIdx.0.List.mapIdx_eq_replicate_iff._simp_1_2 | Init.Data.List.MapIdx | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
_private.Mathlib.RingTheory.GradedAlgebra.Radical.0.Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem._simp_1_3 | Mathlib.RingTheory.GradedAlgebra.Radical | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | false |
IO.AccessRight.mk.injEq | Init.System.IO | ∀ (read write execution read_1 write_1 execution_1 : Bool),
({ read := read, write := write, execution := execution } =
{ read := read_1, write := write_1, execution := execution_1 }) =
(read = read_1 ∧ write = write_1 ∧ execution = execution_1) | true |
Std.DTreeMap.Internal.Impl.get_eq_getD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α], t.WF → ∀ {a : α} {fallback : β a} {h : a ∈ t}, t.get a h = t.getD a fallback | true |
CategoryTheory.MorphismProperty.Over.pullbackComp._proof_1 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P : CategoryTheory.MorphismProperty T} {X Y Z : T}
(f : X ⟶ Y) (g : Y ⟶ Z) [P.IsStableUnderBaseChangeAlong g] [P.HasPullbacksAlong f] [P.HasPullbacksAlong g]
(fg : X ⟶ Z), fg = CategoryTheory.CategoryStruct.comp f g → P.HasPullbacksAlong fg | false |
Real.sinh_lt_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {x : ℝ}, Real.sinh x < x ↔ x < 0 | true |
HomologicalComplex.HomologySequence.composableArrows₃_exact | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι),
c.Rel i j →
∀ [inst_2 : CategoryTheory.CategoryWithHomology C],
(HomologicalComplex.HomologySequence.composableArrows₃ K i j).Exact | true |
Submodule.submoduleOfEquivOfLe._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (h : p ≤ q), Function.LeftInverse (fun m => ⟨⟨↑m, ⋯⟩, ⋯⟩) fun m => ⟨↑↑m, ⋯⟩ | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.elabCommand.match_5 | Lean.Elab.Command | (motive : MProd (Subarray (IO.Promise Lean.Language.DynamicSnapshot)) (MProd (Std.Iter ℕ) Bool) → Sort u_1) →
(r : MProd (Subarray (IO.Promise Lean.Language.DynamicSnapshot)) (MProd (Std.Iter ℕ) Bool)) →
((__s : Subarray (IO.Promise Lean.Language.DynamicSnapshot)) →
(__s_1 : Std.Iter ℕ) → (reusedCmds : Bool) → motive ⟨__s, __s_1, reusedCmds⟩) →
motive r | false |
RingHom.compLeft_apply | Mathlib.Algebra.Ring.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : NonAssocSemiring α] [inst_1 : NonAssocSemiring β] (f : α →+* β) (I : Type u_3)
(h : I → α) (a : I), (f.compLeft I) h a = (⇑f ∘ h) a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.