name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Meta.RefinedDiscrTree.Key.labelledStar.inj | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ {id id_1 : ℕ},
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id_1 → id = id_1 |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.match_syntax.expand.match_7 | Lean.Elab.Quotation | (motive : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term))) →
((tuples : Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → motive (some tuples)) →
(Unit → motive none) → motive x |
Nat.Prime.one_le | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Nat.Prime p → 1 ≤ p |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_4 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] {k : ℕ} {𝒜 : Finset (Finset α)} {s : Finset α},
(s ∈ Finset.falling k 𝒜) = ((∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k) |
Batteries.Tactic.DeclCache._sizeOf_1 | Batteries.Util.Cache | {α : Type} → [SizeOf α] → Batteries.Tactic.DeclCache α → ℕ |
Nat.cast_div_charZero._simp_1 | Mathlib.Data.Nat.Cast.Field | ∀ {K : Type u_1} [inst : DivisionSemiring K] {m n : ℕ} [CharZero K], n ∣ m → ↑m / ↑n = ↑(m / n) |
Decidable.not_and_iff_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a], ¬(a ∧ b) ↔ ¬a ∨ ¬b |
Module.End.hasEigenvalue_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, f.HasEigenvalue μ ↔ f.eigenspace μ ≠ ⊥ |
List.eraseIdx_nil | Init.Data.List.Basic | ∀ {α : Type u} {i : ℕ}, [].eraseIdx i = [] |
CategoryTheory.IsPushout.of_map | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.span f g) F],
CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g i →
CategoryTheory.IsPushout (F.map f) (F.map g) (F.map h) (F.map i) → CategoryTheory.IsPushout f g h i |
Std.Time.DateTime.subNanoseconds | Std.Time.Zoned.DateTime | {tz : Std.Time.TimeZone} → Std.Time.DateTime tz → Std.Time.Nanosecond.Offset → Std.Time.DateTime tz |
List.foldl.match_1.congr_eq_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_3} {β : Type u_1} (motive : α → List β → Sort u_2) (x : α) (x_1 : List β) (h_1 : (a : α) → motive a [])
(h_2 : (a : α) → (b : β) → (l : List β) → motive a (b :: l)) (a : α),
x = a →
x_1 = [] →
(match x, x_1 with
| a, [] => h_1 a
| a, b :: l => h_2 a b l) ≍
h_1 a |
Lean.Elab.Term.StructInst.FieldView.ref | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.FieldView → Lean.Syntax |
AddEquiv.arrowCongr._proof_3 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_4} {N : Type u_1} {P : Type u_3} {Q : Type u_2} [inst : Add P] [inst_1 : Add Q] (f : M ≃ N) (g : P ≃+ Q)
(h k : M → P), (fun n => g ((h + k) (f.symm n))) = (fun n => g (h (f.symm n))) + fun n => g (k (f.symm n)) |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)
[CategoryTheory.CreatesColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) G],
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) C |
NonUnitalSubsemiring.prod_mono_right | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(s : NonUnitalSubsemiring R), Monotone fun t => s.prod t |
StarAlgHom.realContinuousMapOfNNReal._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] {A : Type u_1} [inst_1 : Ring A] [inst_2 : StarRing A]
[inst_3 : Algebra ℝ A] (φ : C(X, NNReal) →⋆ₐ[NNReal] A) (f g : C(X, ℝ)),
φ (f * g).toNNReal - φ (-(f * g)).toNNReal = (φ f.toNNReal - φ (-f).toNNReal) * (φ g.toNNReal - φ (-g).toNNReal) |
profiniteToCompHaus | Mathlib.Topology.Category.Profinite.Basic | CategoryTheory.Functor Profinite CompHaus |
iterateInduction.eq_2 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {X : ℕ → Type u_1} {a : ℕ} (x : (i : ↥(Finset.Iic a)) → X ↑i)
(ind : (n : ℕ) → ((i : ↥(Finset.Iic n)) → X ↑i) → X (n + 1)) (k : ℕ),
iterateInduction x ind k.succ = if h : k + 1 ≤ a then x ⟨k + 1, ⋯⟩ else ind k fun i => iterateInduction x ind ↑i |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs._sunfold | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.instDecidableEqStained.decEq._proof_8 | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.Stained.wildcard✝ = Mathlib.Linter.Flexible.Stained.goal✝ → False |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.StructInstState.fields._default | Lean.Elab.StructInst | Array Lean.Expr |
_private.Batteries.Data.Array.Scan.0.Array.getElem?_scanl._proof_1_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {a : β} {l : Array α} {i : ℕ} {f : β → α → β},
i + 1 ≤ (Array.scanl f a l).size → i < (Array.scanl f a l).size |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.id.match_1.eq_2 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithInitial C → Sort u_2)
(h_1 : (a : C) → motive (CategoryTheory.WithInitial.of a)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_2 ()) =
h_2 () |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkListLitAux._sunfold | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → List Lean.Expr → Lean.Expr |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.ZariskisMainProperty.of_adjoin_eq_top._simp_1_9 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_2} [inst : Ring R] (f : Polynomial R), f.eraseLead = f - (Polynomial.monomial f.natDegree) f.leadingCoeff |
CochainComplex.mappingCone.rotateHomotopyEquiv_comm₂_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj
(CochainComplex.mappingCone (CochainComplex.mappingCone.inr φ)) ⟶
Z),
CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingCone.triangle φ).mor₃)
(CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (CochainComplex.mappingCone.rotateHomotopyEquiv φ).hom)
h) =
CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
(CochainComplex.mappingCone.inr (CochainComplex.mappingCone.inr φ)))
h |
Polynomial.Sequence.elems' | Mathlib.Algebra.Polynomial.Sequence | {R : Type u_1} → [inst : Semiring R] → Polynomial.Sequence R → ℕ → Polynomial R |
CategoryTheory.Grothendieck.isoMk._proof_3 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (e₁ : X.base ≅ Y.base) (e₂ : (F.map e₁.hom).toFunctor.obj X.fiber ≅ Y.fiber),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp { base := e₁.hom, fiber := e₂.hom }
{ base := e₁.inv,
fiber :=
CategoryTheory.CategoryStruct.comp ((F.map e₁.inv).toFunctor.map e₂.inv)
(CategoryTheory.eqToHom ⋯) }).fiber =
(CategoryTheory.CategoryStruct.id X).fiber |
CategoryTheory.Reflective | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor D C → Type (max (max (max u₁ u₂) v₁) v₂) |
AlgebraicGeometry.Scheme.OpenCover.pullbackCoverAffineRefinementObjIso._proof_1 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover) (i : 𝒰.affineRefinement.openCover.I₀),
CategoryTheory.Limits.HasPullback f (𝒰.affineRefinement.openCover.f i) |
Finset.coe_pimage | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, ↑(Finset.pimage f s) = f.image ↑s |
Set.singletonMulHom_apply | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] (a : α), Set.singletonMulHom a = {a} |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.«_aux_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme___macroRules__private_Mathlib_AlgebraicGeometry_ProjectiveSpectrum_Scheme_0_AlgebraicGeometry_termSpec.T__1» | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.Macro |
Lean.Parser.Tactic._aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mrevertError_1 | Std.Tactic.Do.Syntax | Lean.Macro |
MvPolynomial.zeroLocus_span | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3}
(S : Set (MvPolynomial σ k)), MvPolynomial.zeroLocus K (Ideal.span S) = {x | ∀ p ∈ S, (MvPolynomial.aeval x) p = 0} |
_private.Mathlib.Tactic.Push.0.Mathlib.Tactic.Push.elabPushTree._sparseCasesOn_3 | Mathlib.Tactic.Push | {motive : Mathlib.Tactic.Push.Head → Sort u} →
(t : Mathlib.Tactic.Push.Head) →
motive Mathlib.Tactic.Push.Head.lambda → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
MeasureTheory.Integrable.measure_gt_lt_top | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β} [inst_1 : Lattice β] [HasSolidNorm β] [AddLeftMono β],
MeasureTheory.Integrable f μ → ∀ {ε : β}, 0 < ε → μ {a | ε < f a} < ⊤ |
iteratedDeriv_fun_mul | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜} {𝔸 : Type u_5} [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f g : 𝕜 → 𝔸},
ContDiffAt 𝕜 (↑n) f x →
ContDiffAt 𝕜 (↑n) g x →
iteratedDeriv n (fun x => f x * g x) x =
∑ i ∈ Finset.range (n + 1), ↑(n.choose i) * iteratedDeriv i f x * iteratedDeriv (n - i) g x |
HomologicalComplex.mk._flat_ctor | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} →
(X : ι → V) →
(d : (i j : ι) → X i ⟶ X j) →
autoParam (∀ (i j : ι), ¬c.Rel i j → d i j = 0) HomologicalComplex.shape._autoParam →
autoParam
(∀ (i j k : ι), c.Rel i j → c.Rel j k → CategoryTheory.CategoryStruct.comp (d i j) (d j k) = 0)
HomologicalComplex.d_comp_d'._autoParam →
HomologicalComplex V c |
Std.TreeMap.Raw.getKey!_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂).getKey! k = default |
CategoryTheory.CosimplicialObject.Truncated.trunc._auto_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Syntax |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.consumeForallN._unsafe_rec | Lean.Meta.Sym.Simp.Have | Lean.Expr → ℕ → Lean.Expr |
Std.Internal.USquash.inflate.inj | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {α : Type v} {x : Std.Internal.Small α} {x_1 y : Std.Internal.USquash α}, x_1.inflate = y.inflate → x_1 = y |
instFunLikeMulActionHom._proof_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_3} {N : Type u_4} (φ : M → N) (X : Type u_1) [inst : SMul M X] (Y : Type u_2) [inst_1 : SMul N Y]
(f g : X →ₑ[φ] Y), f.toFun = g.toFun → f = g |
_private.Mathlib.RingTheory.Multiplicity.0.emultiplicity_eq_of_dvd_of_not_dvd._simp_1_4 | Mathlib.RingTheory.Multiplicity | ∀ {p : Prop} [Decidable p], (¬¬p) = p |
AddGroupSeminorm.apply_one | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E), 1 x = if x = 0 then 0 else 1 |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.append_append_left_iff._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} (p : α × Bool), FreeGroup.Red (p :: L₁) (p :: L₂) = FreeGroup.Red L₁ L₂ |
LinearMap.convSemiring._proof_6 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_3} {A : Type u_1} {C : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (n : ℕ), (n + 1).unaryCast = n.unaryCast + 1 |
Subring.inclusion._proof_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] {S T : Subring R}, S ≤ T → ∀ (x : ↥S), S.subtype x ∈ T |
List.pmap_attachWith._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {q : α → Prop} {l : List α} (H₁ : ∀ x ∈ l, q x) (a : α) (h : a ∈ l), ⟨a, ⋯⟩ ∈ l.attachWith q H₁ |
Polynomial.logMahlerMeasure.eq_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (p : Polynomial ℂ), p.logMahlerMeasure = Real.circleAverage (fun x => Real.log ‖Polynomial.eval x p‖) 0 1 |
Lean.Elab.Term.expandParen._regBuiltin.Lean.Elab.Term.expandParen.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit |
FirstOrder.«_aux_Mathlib_ModelTheory_Semantics___macroRules_FirstOrder_term_≅[_]__1» | Mathlib.ModelTheory.Semantics | Lean.Macro |
MvPolynomial.coeff_expand_zero | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ),
p ≠ 0 → ∀ (φ : MvPolynomial σ R), MvPolynomial.coeff 0 ((MvPolynomial.expand p) φ) = MvPolynomial.coeff 0 φ |
Algebra.adjoin_singleton_eq_range_aeval | Mathlib.RingTheory.Adjoin.Polynomial.Basic | ∀ (R : Type u) {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Algebra.adjoin R {x} = (Polynomial.aeval x).range |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_lt_eq'._simp_1_3 | Mathlib.Analysis.Convex.Gauge | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.saveAppOf._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Types | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
UpperSet.infIrred_iff_of_finite | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : PartialOrder α] {s : UpperSet α} [Finite α], InfIrred s ↔ ∃ a, UpperSet.Ici a = s |
groupCohomology | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → Rep k G → ℕ → ModuleCat k |
Set.mul_subset_range | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] [inst_2 : FunLike F α β]
[MulHomClass F α β] (m : F) {s t : Set β}, s ⊆ Set.range ⇑m → t ⊆ Set.range ⇑m → s * t ⊆ Set.range ⇑m |
PartialEquiv.coe_mk | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (s : Set α) (t : Set β) (ml : ∀ ⦃x : α⦄, x ∈ s → f x ∈ t)
(mr : ∀ ⦃x : β⦄, x ∈ t → g x ∈ s) (il : ∀ ⦃x : α⦄, x ∈ s → g (f x) = x) (ir : ∀ ⦃x : β⦄, x ∈ t → f (g x) = x),
↑{ toFun := f, invFun := g, source := s, target := t, map_source' := ml, map_target' := mr, left_inv' := il,
right_inv' := ir } =
f |
MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ - ν).restrict s = μ.restrict s - ν.restrict s |
LinearMap.exact_zero_iff_surjective._simp_1 | Mathlib.Algebra.Exact | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_8} {N : Type u_9} (P : Type u_10) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑f ⇑0 = Function.Surjective ⇑f |
Lean.Meta.Hint.Suggestion.casesOn | Lean.Meta.Hint | {motive : Lean.Meta.Hint.Suggestion → Sort u} →
(t : Lean.Meta.Hint.Suggestion) →
((toTryThisSuggestion : Lean.Meta.Tactic.TryThis.Suggestion) →
(span? previewSpan? : Option Lean.Syntax) →
(diffGranularity : Lean.Meta.Hint.DiffGranularity) →
motive
{ toTryThisSuggestion := toTryThisSuggestion, span? := span?, previewSpan? := previewSpan?,
diffGranularity := diffGranularity }) →
motive t |
_private.Mathlib.Data.List.Defs.0.List.headI.match_1.splitter | Mathlib.Data.List.Defs | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (tail : List α) → motive (a :: tail)) → motive x |
Lean.Environment.getModuleIdxFor? | Lean.Environment | Lean.Environment → Lean.Name → Option Lean.ModuleIdx |
CategoryTheory.Grp.mk.injEq | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) [grp : CategoryTheory.GrpObj X] (X_1 : C) (grp_1 : CategoryTheory.GrpObj X_1),
({ X := X, grp := grp } = { X := X_1, grp := grp_1 }) = (X = X_1 ∧ grp ≍ grp_1) |
Complex.hasSum_deriv_of_summable_norm | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {E : Type u_1} {ι : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set ℂ} {z : ℂ}
{F : ι → ℂ → E} [CompleteSpace E] {u : ι → ℝ},
Summable u →
(∀ (i : ι), DifferentiableOn ℂ (F i) U) →
IsOpen U →
(∀ (i : ι), ∀ w ∈ U, ‖F i w‖ ≤ u i) →
z ∈ U → HasSum (fun i => deriv (F i) z) (deriv (fun w => ∑' (i : ι), F i w) z) |
Submodule.exists_finset_of_mem_iSup | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(p : ι → Submodule R M) {m : M}, m ∈ ⨆ i, p i → ∃ s, m ∈ ⨆ i ∈ s, p i |
IsLeast.bddBelow | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, IsLeast s a → BddBelow s |
Algebra.GrothendieckGroup.instFG | Mathlib.GroupTheory.MonoidLocalization.Finite | ∀ {M : Type u_1} [inst : CommMonoid M] [Monoid.FG M], Monoid.FG (Algebra.GrothendieckGroup M) |
Std.DHashMap.Raw.get?_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∩ m₂).get? k = if k ∈ m₂ then m₁.get? k else none |
SSet.stdSimplex.finSuccAboveOrderIsoFinset._proof_7 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (i : Fin (n + 2)),
Function.LeftInverse
(fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩)
fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩ |
groupHomology.cyclesMk₂_eq._proof_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) (x : ↥(groupHomology.cycles₂ A)),
(CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains A).d 2 1))
((CategoryTheory.ConcreteCategory.hom (groupHomology.chainsIso₂ A).inv) ↑x) =
0 |
LightCondSet.sequentialAdjunction | Mathlib.Condensed.Light.TopCatAdjunction | LightCondSet.lightCondSetToSequential ⊣ LightCondSet.sequentialToLightCondSet |
UInt8.neg_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), -a * b = -(a * b) |
CommSemiRingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier._proof_7 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections]
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp (CategoryTheory.forget₂ CommSemiRingCat SemiRingCat)).comp
(CategoryTheory.forget SemiRingCat)).sections)
⟨fun j =>
((CategoryTheory.forget SemiRingCat).mapCone
((CategoryTheory.forget₂ CommSemiRingCat SemiRingCat).mapCone s)).π.app
j 1,
⋯⟩ =
1 |
RingNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → {inst : NonUnitalNonAssocRing R} → [SizeOf R] → RingNorm R → ℕ |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.simp._sparseCasesOn_11 | Lean.Compiler.LCNF.Simp.Main | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((type : Lean.Expr) → motive_4 (Lean.Compiler.LCNF.Code.unreach type)) →
(Nat.hasNotBit 64 t.ctorIdx → motive_4 t) → motive_4 t |
_private.Mathlib.Tactic.ApplyAt.0.Mathlib.Tactic._aux_Mathlib_Tactic_ApplyAt___elabRules_Mathlib_Tactic_tacticApply_At__1.match_3 | Mathlib.Tactic.ApplyAt | (motive : Lean.Expr × Lean.BinderInfo → Sort u_1) →
(x : Lean.Expr × Lean.BinderInfo) → ((m : Lean.Expr) → (b : Lean.BinderInfo) → motive (m, b)) → motive x |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.AlgHom.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_AlgHom_term↑ₐ_1_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro |
Complex.neg_iff | Mathlib.Analysis.Complex.Order | ∀ {z : ℂ}, z < 0 ↔ z.re < 0 ∧ z.im = 0 |
FirstOrder.Language.DirectLimit.lift._proof_4 | Mathlib.ModelTheory.DirectLimit | ∀ (L : FirstOrder.Language) (ι : Type u_2) [inst : Preorder ι] (G : ι → Type u_3) [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι] {P : Type u_1} [inst_5 : L.Structure P]
(g : (i : ι) → L.Embedding (G i) P) (Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x)
{n : ℕ} (F : L.Functions n) (x : Fin n → FirstOrder.Language.DirectLimit G f),
Quotient.lift (fun x => (g x.fst) x.snd) ⋯ (FirstOrder.Language.Structure.funMap F x) =
FirstOrder.Language.Structure.funMap F (Quotient.lift (fun x => (g x.fst) x.snd) ⋯ ∘ x) |
Std.ExtDTreeMap.get_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ |
eq_iff_eq_cancel_left | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {b c : α}, (∀ {a : α}, a = b ↔ a = c) ↔ b = c |
CategoryTheory.FreeGroupoid.strictUniversalPropertyFixedTarget | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : Type u₁} →
[inst_1 : CategoryTheory.Groupoid G] →
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (CategoryTheory.FreeGroupoid.of C) ⊤ G |
CategoryTheory.ShortComplex.HasRightHomology.hasKernel | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [S.HasRightHomology] [inst_3 : CategoryTheory.Limits.HasCokernel S.f],
CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.desc S.f S.g ⋯) |
UInt8.ofNatLT_add | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (hab : a + b < 2 ^ 8), UInt8.ofNatLT (a + b) hab = UInt8.ofNatLT a ⋯ + UInt8.ofNatLT b ⋯ |
SimpleGraph.completeAtomicBooleanAlgebra._proof_16 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V ι : Type u_1} {κ : ι → Type u_1} (f : (a : ι) → κ a → SimpleGraph V), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.none.elim | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitCandidate✝ → Sort u} →
(t : Lean.Meta.Grind.SplitCandidate✝¹) →
Lean.Meta.Grind.SplitCandidate.ctorIdx✝ t = 0 → motive Lean.Meta.Grind.SplitCandidate.none✝ → motive t |
Aesop.instInhabitedNormalizationState | Aesop.Tree.Data | Inhabited Aesop.NormalizationState |
Set.univ_pi_ite | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) [inst : DecidablePred fun x => x ∈ s] (t : (i : ι) → Set (α i)),
(Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t |
Lean.Parser.ParserState.stxStack._default | Lean.Parser.Types | Lean.Parser.SyntaxStack |
RingHom.FiniteType.comp | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{g : B →+* C} {f : A →+* B}, g.FiniteType → f.FiniteType → (g.comp f).FiniteType |
CategoryTheory.Functor.additive_of_iso | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] {F : CategoryTheory.Functor C D} [F.Additive] {G : CategoryTheory.Functor C D}
(e : F ≅ G), G.Additive |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.ball_smul_closedBall._simp_1_4 | Mathlib.Analysis.Seminorm | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) |
Lean.Elab.Do.ControlLifter.mk.noConfusion | Lean.Elab.Do.Control | {P : Sort u} →
{origCont : Lean.Elab.Do.DoElemCont} →
{returnBase? breakBase? continueBase? : Option Lean.Elab.Do.ControlStack} →
{pureBase : Lean.Elab.Do.ControlStack} →
{pureDeadCode : Lean.Elab.Do.CodeLiveness} →
{liftedDoBlockResultType : Lean.Expr} →
{origCont' : Lean.Elab.Do.DoElemCont} →
{returnBase?' breakBase?' continueBase?' : Option Lean.Elab.Do.ControlStack} →
{pureBase' : Lean.Elab.Do.ControlStack} →
{pureDeadCode' : Lean.Elab.Do.CodeLiveness} →
{liftedDoBlockResultType' : Lean.Expr} →
{ origCont := origCont, returnBase? := returnBase?, breakBase? := breakBase?,
continueBase? := continueBase?, pureBase := pureBase, pureDeadCode := pureDeadCode,
liftedDoBlockResultType := liftedDoBlockResultType } =
{ origCont := origCont', returnBase? := returnBase?', breakBase? := breakBase?',
continueBase? := continueBase?', pureBase := pureBase', pureDeadCode := pureDeadCode',
liftedDoBlockResultType := liftedDoBlockResultType' } →
(origCont = origCont' →
returnBase? = returnBase?' →
breakBase? = breakBase?' →
continueBase? = continueBase?' →
pureBase = pureBase' →
pureDeadCode = pureDeadCode' →
liftedDoBlockResultType = liftedDoBlockResultType' → P) →
P |
Lean.Meta.Grind.SavedState.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SavedState → Sort u} →
(t : Lean.Meta.Grind.SavedState) →
((«meta» : Lean.Meta.SavedState) → (grind : Lean.Meta.Grind.State) → motive { «meta» := «meta», grind := grind }) →
motive t |
Lean.Elab.Tactic.RCases.RCasesPatt.ctorIdx | Lean.Elab.Tactic.RCases | Lean.Elab.Tactic.RCases.RCasesPatt → ℕ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.