name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
MeasureTheory.SimpleFunc.exists_upperSemicontinuous_le_lintegral_le | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [BorelSpace α] {μ : MeasureTheory.Measure α}
[μ.WeaklyRegular] (f : MeasureTheory.SimpleFunc α NNReal),
∫⁻ (x : α), ↑(f x) ∂μ ≠ ⊤ →
∀ {ε : ENNReal},
ε ≠ 0 → ∃ g, (∀ (x : α), g x ≤ f x) ∧ UpperSemicontinuous g ∧ ∫⁻ (x : α), ↑(f x) ∂μ ≤ ∫⁻ (x : α), ↑(g x) ∂μ + ε |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.DerivedLitsInvariant.congr_simp | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (f f_1 : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (e_f : f = f_1)
(fassignments_size : f.assignments.size = n)
(assignments assignments_1 : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(e_assignments : assignments = assignments_1) (assignments_size : assignments.size = n)
(derivedLits derivedLits_1 : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
derivedLits = derivedLits_1 →
f.DerivedLitsInvariant fassignments_size assignments assignments_size derivedLits =
f_1.DerivedLitsInvariant ⋯ assignments_1 ⋯ derivedLits_1 |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.brecOn | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_1 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
((t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) → t.below → motive_1 t) →
((t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) → t.below → motive_2 t) → motive_2 t |
UniformSpace.Completion.instField._proof_13 | Mathlib.Topology.Algebra.UniformField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : UniformSpace K] [inst_2 : IsTopologicalDivisionRing K]
[inst_3 : IsUniformAddGroup K] (x : UniformSpace.Completion K), Semiring.npow 0 x = 1 |
SubAddAction.SMulMemClass.subtype | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} →
{M : Type v} →
[inst : AddMonoid R] →
[inst_1 : AddAction R M] →
{A : Type u_1} → [inst_2 : SetLike A M] → [hA : VAddMemClass A R M] → (S' : A) → ↥S' →ₑ[id] M |
Finsupp.lcoeFun | Mathlib.LinearAlgebra.Finsupp.Pi | {α : Type u_1} →
{M : Type u_2} →
{R : Type u_5} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (α →₀ M) →ₗ[R] α → M |
Turing.TM2to1.StAct.ctorElimType | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} → {motive : Turing.TM2to1.StAct K Γ σ k → Sort u} → ℕ → Sort (max 1 (imax (max (u_2 + 1) (u_4 + 1)) u)) |
_private.Mathlib.AlgebraicGeometry.Noetherian.0.AlgebraicGeometry.isNoetherian_Spec._simp_1_1 | Mathlib.AlgebraicGeometry.Noetherian | ∀ (X : AlgebraicGeometry.Scheme),
AlgebraicGeometry.IsNoetherian X = (AlgebraicGeometry.IsLocallyNoetherian X ∧ CompactSpace ↥X) |
Std.DTreeMap.Internal.RoiSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Roi α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range |
CategoryTheory.Limits.pushout.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] {W : C} {k l : CategoryTheory.Limits.pushout f g ⟶ W},
k = l ↔
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g) k =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g) l ∧
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g) k =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g) l |
HomologicalComplex.Hom.isoOfComponents_hom_f | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : (i : ι) → C₁.X i ≅ C₂.X i)
(hf :
autoParam
(∀ (i j : ι),
c.Rel i j →
CategoryTheory.CategoryStruct.comp (f i).hom (C₂.d i j) =
CategoryTheory.CategoryStruct.comp (C₁.d i j) (f j).hom)
HomologicalComplex.Hom.isoOfComponents._auto_1)
(i : ι), (HomologicalComplex.Hom.isoOfComponents f hf).hom.f i = (f i).hom |
Subsemigroup.comap_le_comap_iff_of_surjective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Surjective ⇑f → ∀ {S T : Subsemigroup N}, Subsemigroup.comap f S ≤ Subsemigroup.comap f T ↔ S ≤ T |
groupHomology.H0π.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G),
groupHomology.H0π A = CategoryTheory.CategoryStruct.comp (groupHomology.cyclesIso₀ A).inv (groupHomology.π A 0) |
OrderMonoidWithZeroHom.ext_iff | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] {f g : α →*₀o β}, f = g ↔ ∀ (a : α), f a = g a |
instIsPrincipalIdealRingOfIsSemisimpleRing | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] [IsSemisimpleRing R], IsPrincipalIdealRing R |
Std.TreeMap.Raw.instLawfulSingletonProd | Std.Data.TreeMap.Raw.Basic | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, LawfulSingleton (α × β) (Std.TreeMap.Raw α β cmp) |
isGreatest_singleton._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGreatest {a} a = True |
AddCancelMonoid.noConfusion | Mathlib.Algebra.Group.Defs | {P : Sort u_1} →
{M : Type u} →
{t : AddCancelMonoid M} →
{M' : Type u} → {t' : AddCancelMonoid M'} → M = M' → t ≍ t' → AddCancelMonoid.noConfusionType P t t' |
Array.extract_append_right | Init.Data.Array.Extract | ∀ {α : Type u_1} {i : ℕ} {as bs : Array α}, (as ++ bs).extract as.size (as.size + i) = bs.extract 0 i |
Lean.Lsp.SymbolKind.number.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 15 → motive Lean.Lsp.SymbolKind.number → motive t |
WithAbs.ofAbs_pow | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) (x : WithAbs v) (n : ℕ), (x ^ n).ofAbs = x.ofAbs ^ n |
Finset.PNat.coe_prod | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_4} (f : ι → ℕ+) (s : Finset ι), ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i) |
_private.Init.Data.String.Lemmas.Pattern.Split.0.String.Slice.Pattern.Model.splitFromSteps.match_1.eq_1 | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} (motive : List (String.Slice.Pattern.SearchStep s) → Sort u_1) (h_1 : Unit → motive [])
(h_2 :
(startPos endPos : s.Pos) →
(l : List (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.Pattern.SearchStep.rejected startPos endPos :: l))
(h_3 :
(p q : s.Pos) →
(l : List (String.Slice.Pattern.SearchStep s)) → motive (String.Slice.Pattern.SearchStep.matched p q :: l)),
(match [] with
| [] => h_1 ()
| String.Slice.Pattern.SearchStep.rejected startPos endPos :: l => h_2 startPos endPos l
| String.Slice.Pattern.SearchStep.matched p q :: l => h_3 p q l) =
h_1 () |
Set.insert_Ioc_right_eq_Ioc_add_one_of_not_isMax | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Add α] [SuccAddOrder α] {a b : α},
a ≤ b → ¬IsMax b → insert (b + 1) (Set.Ioc a b) = Set.Ioc a (b + 1) |
Std.DHashMap.erase_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {k : α}, ∅.erase k = ∅ |
CategoryTheory.Pseudofunctor.casesOn | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.Pseudofunctor B C → Sort u} →
(t : CategoryTheory.Pseudofunctor B C) →
((toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C) →
(mapId :
(a : B) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.CategoryStruct.id (toPrelaxFunctor.obj a)) →
(mapComp :
{a b c : B} →
(f : a ⟶ b) →
(g : b ⟶ c) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.comp f g) ≅
CategoryTheory.CategoryStruct.comp (toPrelaxFunctor.map f) (toPrelaxFunctor.map g)) →
(map₂_whisker_left :
∀ {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerLeft f η) =
CategoryTheory.CategoryStruct.comp (mapComp f g).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (toPrelaxFunctor.map₂ η))
(mapComp f h).inv)) →
(map₂_whisker_right :
∀ {a b c : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.whiskerRight η h) =
CategoryTheory.CategoryStruct.comp (mapComp f h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (toPrelaxFunctor.map₂ η)
(toPrelaxFunctor.map h))
(mapComp g h).inv)) →
(map₂_associator :
∀ {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.associator f g h).hom =
CategoryTheory.CategoryStruct.comp
(mapComp (CategoryTheory.CategoryStruct.comp f g) h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapComp f g).hom (toPrelaxFunctor.map h))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (toPrelaxFunctor.map f)
(toPrelaxFunctor.map g) (toPrelaxFunctor.map h)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f)
(mapComp g h).inv)
(mapComp f (CategoryTheory.CategoryStruct.comp g h)).inv)))) →
(map₂_left_unitor :
∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom =
CategoryTheory.CategoryStruct.comp
(mapComp (CategoryTheory.CategoryStruct.id a) f).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (mapId a).hom (toPrelaxFunctor.map f))
(CategoryTheory.Bicategory.leftUnitor (toPrelaxFunctor.map f)).hom)) →
(map₂_right_unitor :
∀ {a b : B} (f : a ⟶ b),
toPrelaxFunctor.map₂ (CategoryTheory.Bicategory.rightUnitor f).hom =
CategoryTheory.CategoryStruct.comp
(mapComp f (CategoryTheory.CategoryStruct.id b)).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (toPrelaxFunctor.map f) (mapId b).hom)
(CategoryTheory.Bicategory.rightUnitor (toPrelaxFunctor.map f)).hom)) →
motive
{ toPrelaxFunctor := toPrelaxFunctor, mapId := mapId, mapComp := mapComp,
map₂_whisker_left := map₂_whisker_left, map₂_whisker_right := map₂_whisker_right,
map₂_associator := map₂_associator, map₂_left_unitor := map₂_left_unitor,
map₂_right_unitor := map₂_right_unitor }) →
motive t |
Polynomial.isNilpotent_aeval_sub_of_isNilpotent_sub | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Polynomial R)
{a b : S}, IsNilpotent (a - b) → IsNilpotent ((Polynomial.aeval a) P - (Polynomial.aeval b) P) |
Batteries.Tactic.GeneralizeProofs.Config.mk.inj | Batteries.Tactic.GeneralizeProofs | ∀ {maxDepth : ℕ} {abstract debug : Bool} {maxDepth_1 : ℕ} {abstract_1 debug_1 : Bool},
{ maxDepth := maxDepth, abstract := abstract, debug := debug } =
{ maxDepth := maxDepth_1, abstract := abstract_1, debug := debug_1 } →
maxDepth = maxDepth_1 ∧ abstract = abstract_1 ∧ debug = debug_1 |
CategoryTheory.Functor.IsCocartesian.toIsHomLift | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} {inst : CategoryTheory.Category.{v₁, u₁} 𝒮} {inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳}
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [self : p.IsCocartesian f φ],
p.IsHomLift f φ |
padicNorm.eq_zpow_of_nonzero | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ} {q : ℚ}, q ≠ 0 → padicNorm p q = ↑p ^ (-padicValRat p q) |
_private.Lean.Elab.Tactic.Do.ProofMode.Specialize.0.Lean.Elab.Tactic.Do.ProofMode.mSpecializeImpStateful._sparseCasesOn_11 | Lean.Elab.Tactic.Do.ProofMode.Specialize | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Std.DTreeMap.Internal.Impl.decidableEquiv | Std.Data.DTreeMap.Internal.Lemmas | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
[Std.LawfulEqOrd α] →
[inst_3 : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] →
(t₁ t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.WF → t₂.WF → Decidable (t₁.Equiv t₂) |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isNonTrivialRegular.isSimple.match_1 | Lean.Meta.ExprDefEq | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((f a : Lean.Expr) → motive (f.app a)) →
((typeName : Lean.Name) → (idx : ℕ) → (b : Lean.Expr) → motive (Lean.Expr.proj typeName idx b)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
motive e |
SemiRingCat.hasForgetToMonCat._proof_4 | Mathlib.Algebra.Category.Ring.Basic | { obj := fun R => MonCat.of ↑R, map := fun {X Y} f => MonCat.ofHom ↑(SemiRingCat.Hom.hom f),
map_id := SemiRingCat.hasForgetToMonCat._proof_1, map_comp := @SemiRingCat.hasForgetToMonCat._proof_2 }.comp
(CategoryTheory.forget MonCat) =
CategoryTheory.forget SemiRingCat |
rothNumberNat_spec | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ (n : ℕ), ∃ t ⊆ Finset.range n, t.card = rothNumberNat n ∧ ThreeAPFree ↑t |
Lean.Elab.Term.ElabElim.Context.mk.noConfusion | Lean.Elab.App | {P : Sort u} →
{elimInfo : Lean.Elab.Term.ElabElimInfo} →
{expectedType : Lean.Expr} →
{elimInfo' : Lean.Elab.Term.ElabElimInfo} →
{expectedType' : Lean.Expr} →
{ elimInfo := elimInfo, expectedType := expectedType } =
{ elimInfo := elimInfo', expectedType := expectedType' } →
(elimInfo = elimInfo' → expectedType = expectedType' → P) → P |
List.Nodup.mem_diff_iff | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α} {a : α} [inst : BEq α] [LawfulBEq α], l₁.Nodup → (a ∈ l₁.diff l₂ ↔ a ∈ l₁ ∧ a ∉ l₂) |
_private.Batteries.Data.Char.Basic.0.Char.exists_eq_false_of_all_eq_false._proof_1_9 | Batteries.Data.Char.Basic | ∀ (x : Fin 1056768),
↑x + (Char.maxSurrogate + 1) < 55296 ∨ 57343 < ↑x + (Char.maxSurrogate + 1) ∧ ↑x + (Char.maxSurrogate + 1) < 1114112 |
unitsNonZeroDivisorsEquiv._proof_4 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀],
Function.RightInverse (fun u => { val := ⟨↑u, ⋯⟩, inv := ⟨↑u⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ })
(↑(Units.map (nonZeroDivisors M₀).subtype)).toFun |
CategoryTheory.ShortComplex.rightHomologyι_naturality' | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap' φ h₁ h₂) h₂.ι =
CategoryTheory.CategoryStruct.comp h₁.ι (CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂) |
Mathlib.Tactic.Order.OrderType.ctorIdx | Mathlib.Tactic.Order.Preprocessing | Mathlib.Tactic.Order.OrderType → ℕ |
List.zipWithM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (x : List α)
(x_1 : List β),
List.zipWithM' f x x_1 =
match x, x_1 with
| x :: xs, y :: ys => do
let z ← f x y
let zs ← List.zipWithM' f xs ys
pure (z :: zs)
| x, x_2 => pure [] |
Complex.ofRealCLM_norm | Mathlib.Analysis.Complex.OperatorNorm | ‖Complex.ofRealCLM‖ = 1 |
Nat.induct_roo_right | Init.Data.Range.Polymorphic.NatLemmas | ∀ (motive : ℕ → ℕ → Prop),
(∀ (a b : ℕ), b ≤ a + 1 → motive a b) →
(∀ (a b : ℕ), a + 1 ≤ b → motive a b → motive a (b + 1)) → ∀ (a b : ℕ), motive a b |
Profinite.NobelingProof.factors._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Span | ∀ {I : Type u_1} [inst : LinearOrder I], IsTrans I fun x1 x2 => x2 ≤ x1 |
WeierstrassCurve.natDegree_preΨ₄_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R), 2 ≠ 0 → 0 < W.preΨ₄.natDegree |
CategoryTheory.Preadditive.ofFullyFaithful._proof_1 | Mathlib.CategoryTheory.Preadditive.Transfer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Preadditive D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
F.map (CategoryTheory.CategoryStruct.comp (f + f') g) =
F.map (CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f' g) |
Homotopy.extend.homAux.eq_2 | Mathlib.Algebra.Homology.Embedding.ExtendHomotopy | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
{K L : HomologicalComplex C c} (φ : (i j : ι) → K.X i ⟶ L.X j) (i' : Option ι),
(i' = none → False) → Homotopy.extend.homAux φ i' none = 0 |
instNonUnitalNonAssocRingWithConvMatrix._proof_3 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {α : Type u_1} {m : Type u_3} {n : Type u_2} [inst : NonUnitalNonAssocRing α] (a : WithConv (Matrix m n α)), 0 * a = 0 |
AddSubgroup.unop_bot | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G], ⊥.unop = ⊥ |
String.Pos.Raw.utf8SetAux.eq_1 | Init.Data.String.Basic | ∀ (c' : Char) (x x_1 : String.Pos.Raw), String.Pos.Raw.utf8SetAux c' [] x x_1 = [] |
CategoryTheory.Triangulated.someOctahedron | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
[CategoryTheory.IsTriangulated C] →
{X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} →
{u₁₂ : X₁ ⟶ X₂} →
{u₂₃ : X₂ ⟶ X₃} →
{u₁₃ : X₁ ⟶ X₃} →
(comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃) →
{v₁₂ : X₂ ⟶ Z₁₂} →
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
(h₁₂ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
{v₂₃ : X₃ ⟶ Z₂₃} →
{w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂} →
(h₂₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
{v₁₃ : X₃ ⟶ Z₁₃} →
{w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
(h₁₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
CategoryTheory.Triangulated.Octahedron comm h₁₂ h₂₃ h₁₃ |
Int.fdiv_eq_tdiv | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ},
a.fdiv b =
a.tdiv b - if b ∣ a then 0 else if 0 ≤ a then if 0 ≤ b then 0 else 1 else if 0 ≤ b then b.sign else 1 + b.sign |
Nat.getElem!_toList_roo_eq_add | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n - (m + 1) → (m<...n).toList[i]! = m + 1 + i |
Lean.Grind.ToInt.Div.mk | Init.Grind.ToInt | ∀ {α : Type u} [inst : Div α] {I : outParam Lean.Grind.IntInterval} [inst_1 : Lean.Grind.ToInt α I],
(∀ (x y : α), ↑(x / y) = ↑x / ↑y) → Lean.Grind.ToInt.Div α I |
Convex.eq_1 | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (s : Set E), Convex 𝕜 s = ∀ ⦃x : E⦄, x ∈ s → StarConvex 𝕜 x s |
Polynomial.contract_C | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), Polynomial.contract p (Polynomial.C r) = Polynomial.C r |
MeasureTheory.VAddInvariantMeasure.casesOn | Mathlib.MeasureTheory.Group.Defs | {M : Type u_1} →
{α : Type u_2} →
[inst : VAdd M α] →
{x : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.VAddInvariantMeasure M α μ → Sort u} →
(t : MeasureTheory.VAddInvariantMeasure M α μ) →
((measure_preimage_vadd : ∀ (c : M) ⦃s : Set α⦄, MeasurableSet s → μ ((fun x => c +ᵥ x) ⁻¹' s) = μ s) →
motive ⋯) →
motive t |
LieAlgebra.lieCharacter_apply_lie' | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(χ : LieAlgebra.LieCharacter R L) (x y : L), ⁅χ x, χ y⁆ = 0 |
HSpace.prod._proof_10 | Mathlib.Topology.Homotopy.HSpaces | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : HSpace X]
[inst_3 : HSpace Y] (hG : Continuous fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2))) (x : X × Y),
{ toFun := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)), continuous_toFun := hG }.toFun (1, x) =
(ContinuousMap.id (X × Y)) x |
quadraticChar_exists_neg_one | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F],
ringChar F ≠ 2 → ∃ a, (quadraticChar F) a = -1 |
CategoryTheory.ObjectProperty.prop_of_isColimit_cofan | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteCoproducts] {J : Type u_2} [Finite J] {f : J → C} {F : CategoryTheory.Limits.Cofan f}
(hF : CategoryTheory.Limits.IsColimit F), (∀ (j : J), P (f j)) → P F.pt |
Std.TreeMap.Raw.WF.emptyc | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.WF |
Finset.noncommSum_lemma | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid β] (s : Finset α) (f : α → β),
(↑s).Pairwise (Function.onFun AddCommute f) → {x | x ∈ Multiset.map f s.val}.Pairwise AddCommute |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (k : ℤ) (y? : Option Int.Linear.Var) (c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c) = 1 + sizeOf k + sizeOf y? + sizeOf c |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] (L : CategoryTheory.Functor C₂ D) [inst_3 : L.IsLocalization W₂]
{X₂ : C₂} {X₃ : D} (y : L.obj X₂ ⟶ X₃),
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution Φ L y =
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution Φ L y |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.saveBVar | Lean.Meta.Tactic.Grind.EMatchTheorem | ℕ → Lean.Meta.Grind.NormalizePattern.M✝ Unit |
Polynomial.separable_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], (Polynomial.cyclotomic n K).Separable |
Nat.bit_mod_two | Mathlib.Data.Nat.BinaryRec | ∀ (b : Bool) (n : ℕ), Nat.bit b n % 2 = b.toNat |
Squash.mk | Init.Core | {α : Sort u} → α → Squash α |
continuous_finsum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M},
(∀ (i : ι), Continuous (f i)) →
(LocallyFinite fun i => Function.support (f i)) → Continuous fun x => ∑ᶠ (i : ι), f i x |
Mathlib.Tactic.ITauto.Context.format | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Std.Format |
Erased.instToString | Mathlib.Data.Erased | (α : Type u) → ToString (Erased α) |
FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] {F : Type w} [inst_5 : AddCommGroup F]
[inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [IsTopologicalAddGroup F] [ContinuousSMul 𝕜 F] [CompleteSpace 𝕜]
[T2Space E] [T2Space F] [FiniteDimensional 𝕜 E] [FiniteDimensional 𝕜 F],
Module.finrank 𝕜 E = Module.finrank 𝕜 F → Nonempty (E ≃L[𝕜] F) |
Matrix.transposeᵣ.eq_2 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x n : ℕ) (A : Matrix (Fin x) (Fin (n + 1)) α),
A.transposeᵣ = Matrix.of (Matrix.vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ).transposeᵣ) |
_private.Init.Data.SInt.Lemmas.0.Int32.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x < y) = (x.toInt < y.toInt) |
Lean.instInhabitedScopedEnvExtension.default | Lean.ScopedEnvExtension | {a : Type} → [Inhabited a] → {a_1 a_2 : Type} → Lean.ScopedEnvExtension a a_1 a_2 |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.solveMonoCall._sparseCasesOn_1 | Lean.Elab.Tactic.Monotonicity | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Init.Data.String.Iterate.0.String.Slice.revBytes._proof_1 | Init.Data.String.Iterate | ∀ (s : String.Slice), s.endPos.offset ≤ s.rawEndPos |
MonadFinally | Init.Control.Except | (Type u → Type v) → Type (max (u + 1) v) |
LinearAlgebra.FreeProduct.ι' | Mathlib.LinearAlgebra.FreeProduct.Basic | {I : Type u} →
[inst : DecidableEq I] →
(R : Type v) →
[inst_1 : CommSemiring R] →
(A : I → Type w) →
[inst_2 : (i : I) → Semiring (A i)] →
[inst_3 : (i : I) → Algebra R (A i)] → (DirectSum I fun i => A i) →ₗ[R] LinearAlgebra.FreeProduct R A |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork_φQ | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(hc₁ : CategoryTheory.Limits.IsLimit c₁) (hf₂ : S₂.f = 0) (c₂ : CategoryTheory.Limits.KernelFork S₂.g)
(hc₂ : CategoryTheory.Limits.IsLimit c₂) (f : c₁.pt ⟶ c₂.pt)
(comm :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι c₁) φ.τ₂ =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.Fork.ι c₂)),
(CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork φ hf₁ c₁ hc₁ hf₂ c₂ hc₂ f comm).φQ = φ.τ₂ |
Tactic.ComputeAsymptotics.Seq.dist_nil_cons | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (x : α) (s : Stream'.Seq α), dist Stream'.Seq.nil (Stream'.Seq.cons x s) = 1 |
Module.Grassmannian._sizeOf_1 | Mathlib.RingTheory.Grassmannian | {R : Type u} →
{inst : CommRing R} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → {k : ℕ} → [SizeOf R] → [SizeOf M] → Module.Grassmannian R M k → ℕ |
Lean.IR.CollectMaps.collectParams | Lean.Compiler.IR.EmitUtil | Array Lean.IR.Param → Lean.IR.CollectMaps.Collector |
Subsemiring.distribMulAction | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : Semiring R'] →
[inst_1 : AddMonoid α] → [DistribMulAction R' α] → (S : Subsemiring R') → DistribMulAction (↥S) α |
UniformSpace.ofCoreEq._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (u : UniformSpace.Core α) (t : TopologicalSpace α),
t = u.toTopologicalSpace → ∀ (x : α), nhds x = Filter.comap (Prod.mk x) u.uniformity |
CategoryTheory.faithful_linearYoneda | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C],
(CategoryTheory.linearYoneda R C).Faithful |
Prod.finite_iff | Mathlib.Data.Finite.Prod | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β], Finite (α × β) ↔ Finite α ∧ Finite β |
Std.DTreeMap.Internal.Impl.erase._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l r : Std.DTreeMap.Internal.Impl α β)
(h : (Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Balanced) (l' : Std.DTreeMap.Internal.Impl α β)
(hl'₁ : l'.Balanced) (hl'₂ : l.size - 1 ≤ l'.size) (hl'₃ : l'.size ≤ l.size),
(Std.DTreeMap.Internal.Impl.balanceRErase k' v' l' r ⋯ ⋯ ⋯).Balanced |
_private.Init.Data.Array.Lemmas.0.Array.back_append_right._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, 0 < ys.size → ¬0 < xs.size + ys.size → False |
Lean.Widget.WidgetSource.rec | Lean.Widget.UserWidget | {motive : Lean.Widget.WidgetSource → Sort u} →
((sourcetext : String) → motive { sourcetext := sourcetext }) → (t : Lean.Widget.WidgetSource) → motive t |
MeasureTheory.LocallyIntegrable.exists_nat_integrableOn | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ : MeasureTheory.Measure X} [SecondCountableTopology X],
MeasureTheory.LocallyIntegrable f μ →
∃ u, (∀ (n : ℕ), IsOpen (u n)) ∧ ⋃ n, u n = Set.univ ∧ ∀ (n : ℕ), MeasureTheory.IntegrableOn f (u n) μ |
ComplexShape.χ | Mathlib.Algebra.Homology.EulerCharacteristic | {ι : Type u_1} → (c : ComplexShape ι) → [c.EulerCharSigns] → ι → ℤˣ |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.BadChar.rec | Mathlib.NumberTheory.LSeries.Nonvanishing | {N : ℕ} →
[inst : NeZero N] →
{motive : DirichletCharacter.BadChar✝ N → Sort u} →
((χ : DirichletCharacter ℂ N) →
(χ_ne : χ ≠ 1) →
(χ_sq : χ ^ 2 = 1) →
(hχ : DirichletCharacter.LFunction χ 1 = 0) → motive { χ := χ, χ_ne := χ_ne, χ_sq := χ_sq, hχ := hχ }) →
(t : DirichletCharacter.BadChar✝¹ N) → motive t |
_private.Mathlib.GroupTheory.GroupAction.MultipleTransitivity.0.SubMulAction.ofFixingSubgroup.isMultiplyPretransitive._simp_1_2 | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ {G : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Group G] [inst_1 : MulAction G β] (g : G) (f : α ↪ β) (a : α),
g • f a = (g • f) a |
PositiveLinearMap.preGNS_norm_def | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] (f : A →ₚ[ℂ] ℂ) [inst_2 : StarOrderedRing A]
(a : f.PreGNS), ‖a‖ = √(f (star (f.ofPreGNS a) * f.ofPreGNS a)).re |
Subgroup.Normal.conj_smul_eq_self | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : Group G] (g : G) (H : Subgroup G) [h : H.Normal], MulAut.conj g • H = H |
_private.Init.Data.Nat.SOM.0.Nat.SOM.Mon.mul.go.match_1.eq_2 | Init.Data.Nat.SOM | ∀ (motive : Nat.SOM.Mon → Nat.SOM.Mon → Sort u_1) (m₂ : Nat.SOM.Mon) (h_1 : (m₁ : Nat.SOM.Mon) → motive m₁ [])
(h_2 : (m₂ : Nat.SOM.Mon) → motive [] m₂)
(h_3 :
(v₁ : Nat.Linear.Var) →
(m₁ : List Nat.Linear.Var) → (v₂ : Nat.Linear.Var) → (m₂ : List Nat.Linear.Var) → motive (v₁ :: m₁) (v₂ :: m₂)),
(m₂ = [] → False) →
(match [], m₂ with
| m₁, [] => h_1 m₁
| [], m₂ => h_2 m₂
| v₁ :: m₁, v₂ :: m₂ => h_3 v₁ m₁ v₂ m₂) =
h_2 m₂ |
AlgebraicGeometry.specTargetImageFactorization._proof_1 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {A : CommRingCat} (f : X ⟶ AlgebraicGeometry.Spec A),
AlgebraicGeometry.specTargetImageIdeal f ≤ AlgebraicGeometry.specTargetImageIdeal f |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.