name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
AddSubmonoid.multiples._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_1} [inst : AddMonoid A] (x n : A) (i : ℕ), (fun i => i • x) i = n ↔ ((multiplesHom A) x) i = n |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_13 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (I : Finset (Set α)),
↑I ⊆ {s | ∃ u v, u ≤ v ∧ s = Set.Ioc u v} →
∀ (u v : α),
v ∈ ⋃₀ ↑I →
∀ (u' : α),
v ∈ Set.Ioc u' v →
(Set.Ioc u' v ∪ ⋃₀ ↑(I.erase (Set.Ioc u' v))) \ Set.Ioc u' v = ⋃₀ ↑(I.erase (Set.Ioc u' v)) →
Set.Ioc u' v ∪ ⋃₀ ↑(I.erase (Set.Ioc u' v)) = Set.Ioc u v → ⋃₀ ↑(I.erase (Set.Ioc u' v)) = Set.Ioc u u' |
MeasureTheory.aemeasurable_mlconvolution | Mathlib.Analysis.LConvolution | ∀ {G : Type u_1} {mG : MeasurableSpace G} [inst : Group G] [MeasurableMul₂ G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant] [MeasureTheory.SFinite μ] {f g : G → ENNReal},
AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (MeasureTheory.mlconvolution f g μ) μ |
CategoryTheory.SmallObject.functor._proof_11 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
[CategoryTheory.Limits.HasPushouts C]
[inst_2 :
∀ {X S : C} (πX : X ⟶ S),
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX)) C]
{π₁ : CategoryTheory.Arrow C},
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.span (CategoryTheory.SmallObject.functorObjTop f π₁.hom)
(CategoryTheory.SmallObject.functorObjLeft f π₁.hom)) |
LinearEquiv.multilinearMapCongrLeft._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_1} {M₁ : ι → Type u_5} {M₁' : ι → Type u_2} {M₂ : Type u_3} [inst : CommSemiring 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 : ι) → AddCommMonoid (M₁' i)] [inst_6 : (i : ι) → Module R (M₁' i)]
(e : (i : ι) → M₁ i ≃ₗ[R] M₁' i) (x : MultilinearMap R M₁' M₂),
(MultilinearMap.compLinearMapₗ fun x => ↑(e x).symm) ((MultilinearMap.compLinearMapₗ fun x => ↑(e x)).toFun x) = x |
CategoryTheory.Limits.CatCospanTransform.mkIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_10} {B : Type u_6} {C : Type u_1} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_7, u_10} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_4, u_1} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheory.Category.{u_8, u_11} A'] [inst_4 : CategoryTheory.Category.{u_2, u_3} B']
[inst_5 : CategoryTheory.Category.{u_9, u_12} C'] {F' : CategoryTheory.Functor A' B'}
{G' : CategoryTheory.Functor C' B'} {ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'}
(right : ψ.right ≅ ψ'.right) (base : ψ.base ≅ ψ'.base),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso G ψ.right ψ.base G').hom
(CategoryTheory.Functor.whiskerRight right.hom G') =
CategoryTheory.CategoryStruct.comp (G.whiskerLeft base.hom)
(CategoryTheory.CatCommSq.iso G ψ'.right ψ'.base G').hom →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CatCommSq.iso G ψ.right ψ.base G').hom
(CategoryTheory.Functor.whiskerRight right.hom G') =
CategoryTheory.CategoryStruct.comp (G.whiskerLeft base.hom)
(CategoryTheory.CatCommSq.iso G ψ'.right ψ'.base G').hom |
_private.Mathlib.GroupTheory.ArchimedeanDensely.0.Subgroup.isLeast_of_closure_iff_eq_mabs._simp_1_3 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
Lean.Elab.Structural.EqnInfo.fixedParamPerms | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → Lean.Elab.FixedParamPerms |
List.Cursor.at._proof_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} (l : List α) (n : ℕ), List.take n l ++ List.drop n l = l |
CategoryTheory.Tor._proof_2 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) (X : C),
CategoryTheory.NatTrans.leftDerived
((CategoryTheory.MonoidalCategory.tensoringLeft C).map (CategoryTheory.CategoryStruct.id X)) n =
CategoryTheory.CategoryStruct.id (((CategoryTheory.MonoidalCategory.tensoringLeft C).obj X).leftDerived n) |
Nonneg.semiring._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α], Function.Injective fun a => ↑a |
ODE.FunSpace.recOn | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} →
{t₀ : ↑(Set.Icc tmin tmax)} →
{x₀ : E} →
{r L : NNReal} →
{motive : ODE.FunSpace t₀ x₀ r L → Sort u} →
(t : ODE.FunSpace t₀ x₀ r L) →
((toFun : ↑(Set.Icc tmin tmax) → E) →
(lipschitzWith : LipschitzWith L toFun) →
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r) →
motive { toFun := toFun, lipschitzWith := lipschitzWith, mem_closedBall₀ := mem_closedBall₀ }) →
motive t |
_private.Lean.Meta.Basic.0.Lean.Meta.forallMetaTelescopeReducingAux.process._unsafe_rec | Lean.Meta.Basic | Bool →
Option ℕ →
Lean.MetavarKind →
Array Lean.Expr →
Array Lean.BinderInfo → ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_emod_unique'._simp_1_2 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (-a = -b) = (a = b) |
SubStarSemigroup.mk | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(toSubsemigroup : Subsemigroup M) →
(∀ {a : M}, a ∈ toSubsemigroup.carrier → star a ∈ toSubsemigroup.carrier) → SubStarSemigroup M |
Lean.Meta.Grind.Arith.pickUnusedValue | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Meta.Grind.Goal → Std.HashMap Lean.Expr ℚ → Lean.Expr → ℤ → Std.HashSet ℤ → ℤ |
CategoryTheory.Limits.CreatesFiniteProducts.creates._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | Lean.Syntax |
Std.TreeMap.Raw.mem_of_mem_union_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∈ t₁ ∪ t₂ → k ∉ t₁ → k ∈ t₂ |
AlgebraicGeometry.Scheme.qcPrecoverage | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | CategoryTheory.Precoverage AlgebraicGeometry.Scheme |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_388 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Finsupp.degree_add | Mathlib.Data.Finsupp.Weight | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f (x + y) = f x + f y |
Encodable.fintypeArrowOfEncodable | Mathlib.Logic.Encodable.Pi | {α : Type u_2} → {β : Type u_3} → [Encodable α] → [Fintype α] → [Encodable β] → Encodable (α → β) |
continuousOn_tsum | Mathlib.Analysis.Normed.Group.FunctionSeries | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ}
[inst_2 : TopologicalSpace β] {f : α → β → F} {s : Set β},
(∀ (i : α), ContinuousOn (f i) s) →
Summable u → (∀ (n : α), ∀ x ∈ s, ‖f n x‖ ≤ u n) → ContinuousOn (fun x => ∑' (n : α), f n x) s |
Std.HashMap.Raw.Equiv.of_forall_contains_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.contains k = m₂.contains k) → m₁.Equiv m₂ |
HomotopicalAlgebra.CofibrantObject.instWeakEquivalenceHoCatAppιCompResolutionNatTrans | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.CofibrantObject C),
HomotopicalAlgebra.WeakEquivalence (HomotopicalAlgebra.CofibrantObject.HoCat.ιCompResolutionNatTrans.app X) |
VectorFourier.hasFDerivAt_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountableTopology V]
{μ : MeasureTheory.Measure V},
MeasureTheory.Integrable f μ →
MeasureTheory.Integrable (fun v => ‖v‖ * ‖f v‖) μ →
∀ (w : W),
HasFDerivAt (VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₁₂ f)
(VectorFourier.fourierIntegral Real.fourierChar μ L.toLinearMap₁₂ (VectorFourier.fourierSMulRight L f) w) w |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsLE_iff_exists_Ioc_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hl' : w < a), motive ⋯) → motive x |
Ordinal.toZFSetIso_symm_apply | Mathlib.SetTheory.ZFC.Ordinal | ∀ (x : { x // x.IsOrdinal }), (RelIso.symm Ordinal.toZFSetIso) x = (↑x).rank |
CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse_map_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (X : T × T)
{X_1 Y : CategoryTheory.CostructuredArrow (CategoryTheory.Over.forget X.1) X.2} (g : X_1 ⟶ Y),
((CategoryTheory.CostructuredArrow.ofDiagEquivalence.inverse X).map g).left = g.left.left |
AnalyticAt.comp₂_analyticWithinAt | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : NormedAddCommGroup H] [inst_8 : NormedSpace 𝕜 H]
{h : F × G → H} {f : E → F} {g : E → G} {x : E} {s : Set E},
AnalyticAt 𝕜 h (f x, g x) →
AnalyticWithinAt 𝕜 f s x → AnalyticWithinAt 𝕜 g s x → AnalyticWithinAt 𝕜 (fun x => h (f x, g x)) s x |
Batteries.Tactic.triv | Batteries.Tactic.Init | Lean.ParserDescr |
DirectSum.GradeZero.ring._proof_10 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GRing A] (x : A 0) (x_1 : ℕ),
(DirectSum.of A 0) (x ^ x_1) = (DirectSum.of A 0) x ^ x_1 |
Append.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : Append α} → {α' : Type u} → {t' : Append α'} → α = α' → t ≍ t' → Append.noConfusionType P t t' |
LightProfinite.Extend.cone._proof_2 | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Functor LightProfinite C)
(S : LightProfinite) (x x_1 : CategoryTheory.StructuredArrow S FintypeCat.toLightProfinite) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.StructuredArrow S FintypeCat.toLightProfinite)).obj (G.obj S)).map
f)
(G.map x_1.hom) =
CategoryTheory.CategoryStruct.comp (G.map x.hom)
(((CategoryTheory.StructuredArrow.proj S FintypeCat.toLightProfinite).comp
(FintypeCat.toLightProfinite.comp G)).map
f) |
TendstoUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f + f') (g + g') l s |
_private.Mathlib.Data.List.Chain.0.List.isChain_attachWith._proof_1_7 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {p : α → Prop} (head : α) (tail : List α), (∀ x ∈ head :: tail, p x) → tail = [] → ∀ x ∈ [], p x |
CategoryTheory.Quotient.lift | Mathlib.CategoryTheory.Quotient | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(r : HomRel C) →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
(∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) →
CategoryTheory.Functor (CategoryTheory.Quotient r) D |
PNat.modDivAux | Mathlib.Data.PNat.Defs | ℕ+ → ℕ → ℕ → ℕ+ × ℕ |
SBtw.noConfusion | Mathlib.Order.Circular | {P : Sort u} →
{α : Type u_1} → {t : SBtw α} → {α' : Type u_1} → {t' : SBtw α'} → α = α' → t ≍ t' → SBtw.noConfusionType P t t' |
SSet.Subcomplex.Pairing.I | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N |
ProbabilityTheory.Kernel.swapLeft_zero | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ}, ProbabilityTheory.Kernel.swapLeft 0 = 0 |
AddSubsemigroup.le_op_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] {S₁ : AddSubsemigroup Mᵃᵒᵖ} {S₂ : AddSubsemigroup M}, S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂ |
Metric.mem_thickening_iff_exists_edist_lt | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} (E : Set α) (x : α),
x ∈ Metric.thickening δ E ↔ ∃ z ∈ E, edist x z < ENNReal.ofReal δ |
DomAddAct.instZeroOfAddOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [Zero Mᵃᵒᵖ] → Zero Mᵈᵃᵃ |
CategoryTheory.ObjectProperty.trW_iff' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryTheory.ObjectProperty C) [P.IsStableUnderShift ℤ] {Y Z : C} (g : Y ⟶ Z),
P.trW g ↔
∃ X f h,
∃ (_ : CategoryTheory.Pretriangulated.Triangle.mk f g h ∈ CategoryTheory.Pretriangulated.distinguishedTriangles),
P X |
LipschitzWith.lipschitzOnWith | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
{s : Set α}, LipschitzWith K f → LipschitzOnWith K f s |
Multiset.countP_le_of_le | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Multiset α},
s ≤ t → Multiset.countP p s ≤ Multiset.countP p t |
Cardinal.instCommMonoidWithZero._proof_5 | Mathlib.SetTheory.Cardinal.Order | ∀ (n : ℕ) (x : Cardinal.{u_1}), Semiring.npow (n + 1) x = Semiring.npow n x * x |
CategoryTheory.Functor.OplaxMonoidal.id._proof_2 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X X')))
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((CategoryTheory.Functor.id C).map f)
((CategoryTheory.Functor.id C).obj X')) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id C).map (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X'))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y X'))) |
iSup_eq_bot | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥ |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.ExBase.evalNatCast.match_3 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{a : Q(ℕ)} →
(motive : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a») → Sort u_1) →
(__discr : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a»)) →
((expr : Q(«$α»)) →
(vc : Mathlib.Tactic.Ring.ExSum sα expr) →
(p : Q(↑«$a» = «$expr»)) → motive { expr := expr, val := vc, proof := p }) →
motive __discr |
List.dropLast_eq_eraseIdx | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i + 1 = xs.length → xs.dropLast = xs.eraseIdx i |
Lean.Parser.CacheableParserContext.noConfusion | Lean.Parser.Types | {P : Sort u} →
{t t' : Lean.Parser.CacheableParserContext} → t = t' → Lean.Parser.CacheableParserContext.noConfusionType P t t' |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.add_le_union._proof_1_3 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ (n m : ℕ), Finset.range n ∪ Finset.Ico (n + 1) (n + 1 + m) ⊆ Finset.range (n + 1 + m) |
_private.Lean.Environment.0.Lean.AsyncConsts.normalizedTrie | Lean.Environment | Lean.AsyncConsts✝ → Lean.NameTrie Lean.AsyncConst✝ |
Int.mul_fmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod b = 0 |
CategoryTheory.ShortComplex.cyclesMapIso'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' e.inv h₂ h₁)
(CategoryTheory.ShortComplex.cyclesMap' e.hom h₁ h₂) =
CategoryTheory.CategoryStruct.id h₂.K |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalWhiskerRightAux.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.HorizontalComp → Mathlib.Tactic.BicategoryLike.Atom₁ → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.HorizontalComp) →
(x_1 : Mathlib.Tactic.BicategoryLike.Atom₁) →
((η : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁) → motive (Mathlib.Tactic.BicategoryLike.HorizontalComp.of η) f) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(η : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(ηs : Mathlib.Tactic.BicategoryLike.HorizontalComp) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁) →
motive (Mathlib.Tactic.BicategoryLike.HorizontalComp.cons e η ηs) f) →
motive x x_1 |
Array.filter_replicate_of_neg | Init.Data.Array.Lemmas | ∀ {stop n : ℕ} {α : Type u_1} {p : α → Bool} {a : α},
stop = n → ¬p a = true → Array.filter p (Array.replicate n a) 0 stop = #[] |
LieEquiv.invFun | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{L' : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → [inst_3 : LieRing L'] → [inst_4 : LieAlgebra R L'] → (L ≃ₗ⁅R⁆ L') → L' → L |
UniformContinuous.sup_compacts | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β]
{f g : α → TopologicalSpace.Compacts β},
UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x ⊔ g x |
subset_of_subset_of_eq | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] {a b c : α}, a ⊆ b → b = c → a ⊆ c |
toIcoDiv_add_intCast_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoDiv hp a (b + ↑m * p) = toIcoDiv hp a b + m |
Set.biInter_subset_biUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s.Nonempty → ∀ {t : α → Set β}, ⋂ x ∈ s, t x ⊆ ⋃ x ∈ s, t x |
AbstractCompletion.mapEquiv._proof_3 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_3} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_1, u_3} α) {β : Type u_4}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_2, u_4} β) (e : α ≃ᵤ β),
Function.LeftInverse (pkg'.map pkg ⇑e.symm) (pkg.map pkg' ⇑e) |
SymAlg.addMonoid._proof_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : AddMonoid α], SymAlg.unsym 0 = 0 |
CategoryTheory.Coyoneda.colimitCocone_pt | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ),
(CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1} |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNeg | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (value : BitVec w)
(target : aig.RefVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := target.get idx hidx }⟧ = value.getLsbD idx) →
∀ (idx : ℕ) (hidx : idx < w),
⟦assign,
{ aig := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNeg aig target).aig,
ref := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNeg aig target).vec.get idx hidx }⟧ =
(-value).getLsbD idx |
Int8.neg_neg | Init.Data.SInt.Lemmas | ∀ {a : Int8}, - -a = a |
_private.Mathlib.Util.CompileInductive.0.Float.mk_eq | Mathlib.Util.CompileInductive | Float.mk = Float.mkImpl✝ |
Std.Do.Spec.forIn'_rii._proof_3 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α] [inst_3 : Std.PRange.LawfulUpwardEnumerable α] {xs : Std.Rii α} (pref : List α)
(cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → pref ++ [cur] ++ suff = xs.toList |
_private.Mathlib.FieldTheory.Normal.Closure.0.isNormalClosure_normalClosure.match_1 | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_3) (K : Type u_2) (L : Type u_1) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (ne : Nonempty (K →ₐ[F] L)),
(∀ (φ : K →ₐ[F] L), motive ⋯) → motive ne |
LieDerivation.instLieRing._proof_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(d e f : LieDerivation R L L), ⁅d + e, f⁆ = ⁅d, f⁆ + ⁅e, f⁆ |
Turing.PartrecToTM2.Λ'.rec | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Λ' → Sort u} →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.move p k₁ k₂ q)) →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k : Turing.PartrecToTM2.K') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.clear p k q)) →
((q : Turing.PartrecToTM2.Λ') → motive q → motive q.copy) →
((k : Turing.PartrecToTM2.K') →
(s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.push k s q)) →
((f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ') →
((a : Option Turing.PartrecToTM2.Γ') → motive (f a)) → motive (Turing.PartrecToTM2.Λ'.read f)) →
((q : Turing.PartrecToTM2.Λ') → motive q → motive q.succ) →
((q₁ q₂ : Turing.PartrecToTM2.Λ') → motive q₁ → motive q₂ → motive (q₁.pred q₂)) →
((k : Turing.PartrecToTM2.Cont') → motive (Turing.PartrecToTM2.Λ'.ret k)) →
(t : Turing.PartrecToTM2.Λ') → motive t |
WithZero.le_log_of_exp_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {G : Type u_3} [inst : Preorder G] {a : G} [inst_1 : AddGroup G] {x : WithZero (Multiplicative G)},
WithZero.exp a ≤ x → a ≤ x.log |
Rep.FiniteCyclicGroup.groupHomologyIsoOdd._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep k G) (g : G),
(Rep.FiniteCyclicGroup.normHomCompSub A g).HasHomology |
EReal.neTopBotEquivReal._proof_7 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (fun x => (↑x).toReal) ((fun x => ⟨↑x, ⋯⟩) x) = x |
LinearMap.tensorKerBil._proof_6 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N] [inst_10 : Module R P]
(f : N →ₗ[R] P), SMulCommClass R S ↥((TensorProduct.AlgebraTensorModule.lTensor S M) f).ker |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe | Mathlib.Tactic.FBinop | FBinopElab.Tree✝ → FBinopElab.SRec → Lean.Elab.TermElabM FBinopElab.Tree✝¹ |
max_le_max_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b : α} (c : α), a ≤ b → max c a ≤ max c b |
Mathlib.Meta.FunProp.FunctionData.casesOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.FunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionData) →
((lctx : Lean.LocalContext) →
(insts : Lean.LocalInstances) →
(fn : Lean.Expr) →
(args : Array Mathlib.Meta.FunProp.Mor.Arg) →
(mainVar : Lean.Expr) →
(mainArgs : Array ℕ) →
motive
{ lctx := lctx, insts := insts, fn := fn, args := args, mainVar := mainVar,
mainArgs := mainArgs }) →
motive t |
FourierSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransform E F],
(∀ (r : R) (f : E), FourierTransform.fourier (r • f) = r • FourierTransform.fourier f) → FourierSMul R E F |
Subfield.relfinrank_map_map | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {L : Type w} [inst_1 : Field L] (A B : Subfield E) (f : E →+* L),
(Subfield.map f A).relfinrank (Subfield.map f B) = A.relfinrank B |
SkewMonoidAlgebra.addHom_ext_iff | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {M : Type u_3} [inst_1 : AddZeroClass M]
{f g : SkewMonoidAlgebra k G →+ M},
f = g ↔ ∀ (a : G) (b : k), f (SkewMonoidAlgebra.single a b) = g (SkewMonoidAlgebra.single a b) |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) (decVar : Lean.FVarId) (h : Lean.Meta.Grind.Arith.Cutsat.UnsatProof)
(decVars : Array Lean.FVarId),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit c₁ decVar h decVars) =
1 + sizeOf c₁ + sizeOf decVar + sizeOf h + sizeOf decVars |
Std.Internal.List.getValueCast_modifyKey._proof_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.containsKey k' (Std.Internal.List.modifyKey k f l) = true →
Std.Internal.List.containsKey k' l = true |
Lean.Meta.Grind.Arith.CommRing.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.State → Lean.Meta.Grind.Arith.CommRing.State → Sort u |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.measurable_stoppedValue._simp_1_7 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) |
ZMod.val.match_1 | Mathlib.Data.ZMod.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
Finset.mul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], Finset.mul = { mul := Finset.image₂ fun x1 x2 => x1 * x2 } |
NonemptyInterval.subtractionCommMonoid._proof_10 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α],
CovariantClass α α (Function.swap fun x1 x2 => x1 + x2) fun x1 x2 => x1 ≤ x2 |
_private.Init.Data.Option.Lemmas.0.Option.merge.match_1.eq_4 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : Option α → Option α → Sort u_2) (x y : α) (h_1 : Unit → motive none none)
(h_2 : (x : α) → motive (some x) none) (h_3 : (y : α) → motive none (some y))
(h_4 : (x y : α) → motive (some x) (some y)),
(match some x, some y with
| none, none => h_1 ()
| some x, none => h_2 x
| none, some y => h_3 y
| some x, some y => h_4 x y) =
h_4 x y |
CategoryTheory.Limits.isLimitConeOfCoconeUnop._proof_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ)
{c : CategoryTheory.Limits.Cocone F.unop} (hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F)
(j : Jᵒᵖ),
(CategoryTheory.CategoryStruct.comp (hc.desc (CategoryTheory.Limits.coconeUnopOfCone s)).op
((CategoryTheory.Limits.coneOfCoconeUnop c).π.app j)).unop =
(s.π.app j).unop |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Std.Packages.LinearPreorderOfOrdArgs.decidableLT._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax |
PythagoreanTriple.mul_isClassified | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ), h.IsClassified → ⋯.IsClassified |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE.getTFAEList.match_1 | Mathlib.Tactic.TFAE | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) →
((tfae : Lean.Expr) → (l : Q(List Prop)) → motive (tfae.app l)) → ((x : Lean.Expr) → motive x) → motive __discr |
ULift.leftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelSemigroup α],
ULift.leftCancelSemigroup = Function.Injective.leftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.SMul.0.MeasureTheory.eLpNormEssSup_const_smul_le._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
[inst_2 : SMulZeroClass α β] [IsBoundedSMul α β] (r : α) (x : β), (‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊) = True |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.conjGL_coe._simp_1_4 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Group α] [inst_2 : MulDistribMulAction α G] {a : α}
{S : Subgroup G} {x : G}, (x ∈ a⁻¹ • S) = (a • x ∈ S) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.