name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
instCommutativeInt64HAnd | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 &&& x2 |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {a b : Lean.Expr} {natStructId : ℕ} {lhs rhs : Lean.Meta.Grind.Arith.Linear.LinExpr} {a_1 b_1 : Lean.Expr}
{natStructId_1 : ℕ} {lhs_1 rhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat a b natStructId lhs rhs =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coreOfNat a_1 b_1 natStructId_1 lhs_1 rhs_1 →
a = a_1 ∧ b = b_1 ∧ natStructId = natStructId_1 ∧ lhs = lhs_1 ∧ rhs = rhs_1 |
Equiv.equivCongr_refl_left | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (bg : β ≃ γ) (e : α ≃ β), ((Equiv.refl α).equivCongr bg) e = e.trans bg |
IsClosedMap | Mathlib.Topology.Defs.Basic | {X : Type u} → {Y : Type v} → [TopologicalSpace X] → [TopologicalSpace Y] → (X → Y) → Prop |
ContinuousMultilinearMap.seminorm._proof_3 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G], SMulCommClass 𝕜 𝕜 G |
SemilatticeSup.mk.noConfusion | Mathlib.Order.Lattice | {α : Type u} →
{P : Sort u_1} →
{toPartialOrder : PartialOrder α} →
{sup : α → α → α} →
{le_sup_left : ∀ (a b : α), a ≤ sup a b} →
{le_sup_right : ∀ (a b : α), b ≤ sup a b} →
{sup_le : ∀ (a b c : α), a ≤ c → b ≤ c → sup a b ≤ c} →
{toPartialOrder' : PartialOrder α} →
{sup' : α → α → α} →
{le_sup_left' : ∀ (a b : α), a ≤ sup' a b} →
{le_sup_right' : ∀ (a b : α), b ≤ sup' a b} →
{sup_le' : ∀ (a b c : α), a ≤ c → b ≤ c → sup' a b ≤ c} →
{ toPartialOrder := toPartialOrder, sup := sup, le_sup_left := le_sup_left,
le_sup_right := le_sup_right, sup_le := sup_le } =
{ toPartialOrder := toPartialOrder', sup := sup', le_sup_left := le_sup_left',
le_sup_right := le_sup_right', sup_le := sup_le' } →
(toPartialOrder ≍ toPartialOrder' → sup ≍ sup' → P) → P |
HasSum.nat_add_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasSum f m → HasSum (fun n => f ↑n + f (-(↑n + 1))) m |
ENNReal.toReal_ofReal_eq_iff._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ {a : ℝ}, ((ENNReal.ofReal a).toReal = a) = (0 ≤ a) |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.init.loop._unsafe_rec | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) →
BitVec cfg.wordSize →
(v : Array (BitVec cfg.wordSize)) → v.size ≤ cfg.stateSize → Vector (BitVec cfg.wordSize) cfg.stateSize |
FirstOrder.Language.BoundedFormula.listDecode._proof_5 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_2} (l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ))
(x :
(y : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)) →
InvImage (fun x1 x2 => x1 < x2) (fun x => x.length) y (Sum.inr (Sum.inr 0) :: l) →
List ((n : ℕ) × L.BoundedFormula α n)),
2 ≤ (x l ⋯).length → 0 < (x l ⋯).length |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.insertMany.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {ρ : Type w} [inst : ForIn Id ρ ((a : α) × β a)] [inst_1 : BEq α] [inst_2 : Hashable α]
(m : Std.DHashMap.Internal.Raw₀ α β) (l : ρ),
m.insertMany l =
(have r := ⟨m, ⋯⟩;
do
let r ←
forIn l r fun x r =>
let r_1 := r;
match x with
| ⟨a, b⟩ =>
have r := ⟨(↑r_1).insert a b, ⋯⟩;
do
pure PUnit.unit
pure (ForInStep.yield r)
have r :
{ m' //
∀ (P : Std.DHashMap.Internal.Raw₀ α β → Prop),
(∀ {m'' : Std.DHashMap.Internal.Raw₀ α β} {a : α} {b : β a}, P m'' → P (m''.insert a b)) → P m → P m' } :=
r
pure r).run |
UpperSet.coe_eq_univ._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s = Set.univ) = (s = ⊥) |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.initFn.match_3._@.Lean.Server.FileWorker.WidgetRequests.4152489880._hygCtx._hyg.2 | Lean.Server.FileWorker.WidgetRequests | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → ((x : Lean.Expr) → motive x) → motive x |
_private.Lean.Data.LBool.0.Lean.LBool.and._sparseCasesOn_1 | Lean.Data.LBool | {motive : Lean.LBool → Sort u} →
(t : Lean.LBool) → motive Lean.LBool.true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
BitVec.toNat_ofInt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (i : ℤ), (BitVec.ofInt n i).toNat = (i % ↑(2 ^ n)).toNat |
Bundle.Trivialization.pullback._proof_4 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_4} {F : Type u_3} {E : B → Type u_1} {B' : Type u_2} [inst : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_1 : TopologicalSpace F] [inst_2 : TopologicalSpace B] [inst_3 : (_b : B) → Zero (E _b)] {K : Type u_5}
[inst_4 : FunLike K B' B] (e : Bundle.Trivialization F Bundle.TotalSpace.proj) (f : K),
∀ y ∈ (⇑f ⁻¹' e.baseSet) ×ˢ Set.univ, ⟨y.1, e.symm (f y.1) y.2⟩ ∈ Bundle.Pullback.lift ⇑f ⁻¹' e.source |
MeasureTheory.MeasurePreserving.withDensity_rnDeriv | Mathlib.Dynamics.Ergodic.RadonNikodym | ∀ {X : Type u_1} {m : MeasurableSpace X} {μ ν : MeasureTheory.Measure X} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.SigmaFinite ν] {f : X → X},
MeasureTheory.MeasurePreserving f μ μ →
MeasureTheory.MeasurePreserving f ν ν →
MeasureTheory.MeasurePreserving f (ν.withDensity (μ.rnDeriv ν)) (ν.withDensity (μ.rnDeriv ν)) |
Countable.LindelofSpace | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] [Countable X], LindelofSpace X |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_integrand_deriv_integrable_A | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ {s : ℂ},
0 < s.re → ∀ {X : ℝ}, 0 ≤ X → IntervalIntegrable (fun x => -(↑(Real.exp (-x)) * ↑x ^ s)) MeasureTheory.volume 0 X |
Stream'.WSeq.LiftRelO | Mathlib.Data.WSeq.Relation | {α : Type u} →
{β : Type v} →
(α → β → Prop) →
(Stream'.WSeq α → Stream'.WSeq β → Prop) → Option (α × Stream'.WSeq α) → Option (β × Stream'.WSeq β) → Prop |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1to1.tr_respects._proof_1_22 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_3} {Λ : Type u_2} {σ : Type u_1} {n : ℕ} {enc : Γ → List.Vector Bool n} (dec : List.Vector Bool n → Γ)
(M : Λ → Turing.TM1.Stmt Γ Λ σ) [inst : Inhabited Γ] {enc0 : enc default = List.Vector.replicate n false}
(p : Γ → σ → Bool) (q₁ q₂ : Turing.TM1.Stmt Γ Λ σ),
(∀ (v : σ) (L R : Turing.ListBlank Γ),
StateTransition.Reaches (Turing.TM1.step (Turing.TM1to1.tr enc dec M))
(Turing.TM1.stepAux (Turing.TM1to1.trNormal dec q₁) v (Turing.TM1to1.trTape' enc0 L R))
(Turing.TM1to1.trCfg enc enc0 (Turing.TM1.stepAux q₁ v (Turing.Tape.mk' L R)))) →
(∀ (v : σ) (L R : Turing.ListBlank Γ),
StateTransition.Reaches (Turing.TM1.step (Turing.TM1to1.tr enc dec M))
(Turing.TM1.stepAux (Turing.TM1to1.trNormal dec q₂) v (Turing.TM1to1.trTape' enc0 L R))
(Turing.TM1to1.trCfg enc enc0 (Turing.TM1.stepAux q₂ v (Turing.Tape.mk' L R)))) →
∀ (v : σ) (L R : Turing.ListBlank Γ),
StateTransition.Reaches (Turing.TM1.step (Turing.TM1to1.tr enc dec M))
(bif p R.head v then Turing.TM1.stepAux (Turing.TM1to1.trNormal dec q₁) v (Turing.TM1to1.trTape' enc0 L R)
else Turing.TM1.stepAux (Turing.TM1to1.trNormal dec q₂) v (Turing.TM1to1.trTape' enc0 L R))
(Turing.TM1to1.trCfg enc enc0
(bif p R.head v then Turing.TM1.stepAux q₁ v (Turing.Tape.mk' L R)
else Turing.TM1.stepAux q₂ v (Turing.Tape.mk' L R))) |
neg_le_of_abs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G}, |a| ≤ b → -b ≤ a |
Filter.ker_principal | Mathlib.Order.Filter.Ker | ∀ {α : Type u_2} (s : Set α), (Filter.principal s).ker = s |
CategoryTheory.Preregular.recOn | Mathlib.CategoryTheory.Sites.Coherent.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Preregular C → Sort u} →
(t : CategoryTheory.Preregular C) →
((exists_fac :
∀ {X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ Y) [CategoryTheory.EffectiveEpi g],
∃ W h,
∃ (_ : CategoryTheory.EffectiveEpi h),
∃ i, CategoryTheory.CategoryStruct.comp i g = CategoryTheory.CategoryStruct.comp h f) →
motive ⋯) →
motive t |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.nextn.eq_def | Batteries.Data.String.Lemmas | ∀ (x : String.Legacy.Iterator) (x_1 : ℕ),
x.nextn x_1 =
match x, x_1 with
| it, 0 => it
| it, i.succ => it.next.nextn i |
CategoryTheory.ShortComplex.Homotopy.ext_iff | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Preadditive C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} {x y : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂},
x = y ↔ x.h₀ = y.h₀ ∧ x.h₁ = y.h₁ ∧ x.h₂ = y.h₂ ∧ x.h₃ = y.h₃ |
MeasureTheory.JordanDecomposition.posPart_finite | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_2} [inst : MeasurableSpace α] (self : MeasureTheory.JordanDecomposition α),
MeasureTheory.IsFiniteMeasure self.posPart |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.processLevel.match_1.eq_2 | Lean.Meta.Sym.Pattern | ∀ (motive : Option ℕ → Sort u_1) (x : Option ℕ) (h_1 : (uidx : ℕ) → motive (some uidx))
(h_2 : (x : Option ℕ) → motive x),
(∀ (uidx : ℕ), x = some uidx → False) →
(match x with
| some uidx => h_1 uidx
| x => h_2 x) =
h_2 x |
IsEvenlyCovered.toTrivialization'._proof_18 | Mathlib.Topology.Covering.Basic | ∀ {E : Type u_3} {X : Type u_1} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {I : Type u_2}
[inst_2 : TopologicalSpace I] {x : X} [inst_3 : Nonempty I] (U : Set X)
(x_1 : x ∈ U ∧ IsOpen U ∧ IsOpen (f ⁻¹' U) ∧ ∃ H, ∀ (x : ↑(f ⁻¹' U)), ↑(H x).1 = f ↑x) (H : ↑(f ⁻¹' U) ≃ₜ ↑U × I),
(∀ (x : ↑(f ⁻¹' U)), ↑(H x).1 = f ↑x) →
∀ (e : E),
f e ∈ U →
(↑{ toFun := fun e => if he : f e ∈ U then (↑(H ⟨e, he⟩).1, (H ⟨e, he⟩).2) else (x, Classical.arbitrary I),
invFun := fun xi => ↑(H.symm (if hx : xi.1 ∈ U then ⟨xi.1, hx⟩ else ⟨x, ⋯⟩, xi.2)), source := f ⁻¹' U,
target := U ×ˢ Set.univ, map_source' := ⋯, map_target' := ⋯, left_inv' := ⋯, right_inv' := ⋯,
open_source := ⋯, open_target := ⋯, continuousOn_toFun := ⋯, continuousOn_invFun := ⋯ }
e).1 =
f e |
Std.LawfulBEqCmp.lawfulBEq | Init.Data.Order.Ord | ∀ {α : Type u} [inst : BEq α] {cmp : α → α → Ordering} [inst_1 : Std.LawfulBEqCmp cmp] [Std.LawfulEqCmp cmp],
LawfulBEq α |
String.Legacy.Iterator.forward._sunfold | Init.Data.String.Iterator | String.Legacy.Iterator → ℕ → String.Legacy.Iterator |
LieGroup.«term𝑳» | Mathlib.Geometry.Manifold.Algebra.Monoid | Lean.ParserDescr |
Lean.Elab.Term.ElabElimInfo.noConfusionType | Lean.Elab.App | Sort u → Lean.Elab.Term.ElabElimInfo → Lean.Elab.Term.ElabElimInfo → Sort u |
Int.lcm_mul_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), (m * n).lcm (k * n) = m.lcm k * n.natAbs |
CategoryTheory.Oplax.OplaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.map f) (app b) ⟶ CategoryTheory.CategoryStruct.comp (app a) (G.map f))
(naturality_naturality :
autoParam
(∀ {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.map₂ η) (app b)) (naturality g) =
CategoryTheory.CategoryStruct.comp (naturality f) (CategoryTheory.Bicategory.whiskerLeft (app a) (G.map₂ η)))
CategoryTheory.Oplax.OplaxTrans.naturality_naturality._autoParam)
(naturality_id :
autoParam
(∀ (a : B),
CategoryTheory.CategoryStruct.comp (naturality (CategoryTheory.CategoryStruct.id a))
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapId a)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapId a) (app a))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (app a)).hom
(CategoryTheory.Bicategory.rightUnitor (app a)).inv))
CategoryTheory.Oplax.OplaxTrans.naturality_id._autoParam)
(naturality_comp :
autoParam
(∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (naturality (CategoryTheory.CategoryStruct.comp f g))
(CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapComp f g)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (app c))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (F.map f) (F.map g) (app c)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (naturality g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (app b) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (naturality f) (G.map g))
(CategoryTheory.Bicategory.associator (app a) (G.map f) (G.map g)).hom)))))
CategoryTheory.Oplax.OplaxTrans.naturality_comp._autoParam),
sizeOf
{ app := app, naturality := naturality, naturality_naturality := naturality_naturality,
naturality_id := naturality_id, naturality_comp := naturality_comp } =
1 |
SimpleGraph.uniqueOfSubsingleton._proof_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} [Subsingleton V] (G : SimpleGraph V), G = ⊥ |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_5, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
{X Y : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))}
(X' : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((PresheafOfModules.pushforward₀OfCommRingCat F R).obj X')
((PresheafOfModules.pushforward₀OfCommRingCat F R).map f))
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((PresheafOfModules.pushforward₀OfCommRingCat F R).obj X')
((PresheafOfModules.pushforward₀OfCommRingCat F R).obj Y))).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj ((PresheafOfModules.pushforward₀OfCommRingCat F R).obj X')
((PresheafOfModules.pushforward₀OfCommRingCat F R).obj X))).hom
((PresheafOfModules.pushforward₀OfCommRingCat F R).map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f)) |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.isSupportedMatch.match_7 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis | (motive : Lean.ConstantInfo → Sort u_1) →
(__discr : Lean.ConstantInfo) →
((inductiveInfo : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo inductiveInfo)) →
((x : Lean.ConstantInfo) → motive x) → motive __discr |
normalClosure.instIsScalarTowerSubtypeMemIntermediateFieldNormalClosure | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_1) (K : Type u_2) (L : Type u_3) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] [inst_5 : Algebra K L] [inst_6 : IsScalarTower F K L],
IsScalarTower F K ↥(IntermediateField.normalClosure F K L) |
Aesop.RuleSetNameFilter.casesOn | Aesop.RuleSet.Filter | {motive : Aesop.RuleSetNameFilter → Sort u} →
(t : Aesop.RuleSetNameFilter) → ((ns : Array Aesop.RuleSetName) → motive { ns := ns }) → motive t |
CategoryTheory.ComposableArrows.fourδ₄Toδ₃_app_one | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₃₄ : i₂ ⟶ i₄) (h₃₄ : CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄),
(CategoryTheory.ComposableArrows.fourδ₄Toδ₃ f₁ f₂ f₃ f₄ f₃₄ h₃₄).app 1 =
CategoryTheory.CategoryStruct.id ((CategoryTheory.ComposableArrows.mk₃ f₁ f₂ f₃).obj 1) |
Std.Rco.size_eq_if_roo | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size = if r.lower < r.upper then (r.lower<...r.upper).size + 1 else 0 |
ByteArray.Iterator.mk.sizeOf_spec | Init.Data.ByteArray.Basic | ∀ (array : ByteArray) (idx : ℕ), sizeOf { array := array, idx := idx } = 1 + sizeOf array + sizeOf idx |
Ideal.Quotient.algebra._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_2} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A],
IsScalarTower R₁ A A |
le_total_of_codirected | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] {r v₁ v₂ : α},
r ≤ v₁ → r ≤ v₂ → v₁ ≤ v₂ ∨ v₂ ≤ v₁ |
MeasureTheory.Measure.OuterRegular.of_restrict | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [OpensMeasurableSpace α]
{μ : MeasureTheory.Measure α} {s : ℕ → Set α},
(∀ (n : ℕ), (μ.restrict (s n)).OuterRegular) → (∀ (n : ℕ), IsOpen (s n)) → Set.univ ⊆ ⋃ n, s n → μ.OuterRegular |
Field.rank_mul_sepDegree_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type v) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E],
Module.rank F E * Field.sepDegree E K = Field.sepDegree F K |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_5 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β], ⇑0 = 0 |
MulOpposite.instSemiring._proof_4 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), ↑(n + 1) = ↑n + 1 |
CategoryTheory.ReflPrefunctor._aux_Mathlib_Combinatorics_Quiver_ReflQuiver___unexpand_CategoryTheory_ReflPrefunctor_comp_1 | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.PrettyPrinter.Unexpander |
WeakFEPair.hg_top | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (self : WeakFEPair E) (r : ℝ),
(fun x => self.g x - self.g₀) =O[Filter.atTop] fun x => x ^ r |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.find?_toList_eq_none_iff_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
pow_eq_pow_iff_of_ne_zero | Mathlib.Algebra.Order.Ring.Abs | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a b : R} {n : ℕ},
n ≠ 0 → (a ^ n = b ^ n ↔ a = b ∨ a = -b ∧ Even n) |
Lean.Widget.UserWidgetDefinition.noConfusion | Lean.Widget.UserWidget | {P : Sort u} →
{t t' : Lean.Widget.UserWidgetDefinition} → t = t' → Lean.Widget.UserWidgetDefinition.noConfusionType P t t' |
Std.DTreeMap.Raw.Const.size_ofList | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] {l : List (α × β)},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l → (Std.DTreeMap.Raw.Const.ofList l cmp).size = l.length |
CategoryTheory.Limits.cospanExt_hom_app_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Z} {g : Y ⟶ Z} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iZ.hom)
(wg : CategoryTheory.CategoryStruct.comp iY.hom g' = CategoryTheory.CategoryStruct.comp g iZ.hom),
(CategoryTheory.Limits.cospanExt iX iY iZ wf wg).hom.app CategoryTheory.Limits.WalkingCospan.left = iX.hom |
Cardinal.mk_congr_lift | Mathlib.SetTheory.Cardinal.Defs | ∀ {α : Type u} {β : Type v} (e : α ≃ β), Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.remainingGoals.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic) (goals : List Lean.MessageData),
sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.remainingGoals✝ stx goals) = 1 + sizeOf stx + sizeOf goals |
Mathlib.Tactic.FieldSimp.DenomCondition._sizeOf_inst | Mathlib.Tactic.FieldSimp | {v : Lean.Level} → {M : Q(Type v)} → (iM : Q(GroupWithZero «$M»)) → SizeOf (Mathlib.Tactic.FieldSimp.DenomCondition iM) |
_private.Lean.LoadDynlib.0.Lean.loadPlugin.match_10 | Lean.LoadDynlib | (motive : Option String → Sort u_1) →
(x : Option String) → ((name : String) → motive (some name)) → ((x : Option String) → motive x) → motive x |
Measurable.isGLB | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} {δ : Type u_4} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [BorelSpace α]
{mδ : MeasurableSpace δ} [inst_2 : LinearOrder α] [OrderTopology α] [SecondCountableTopology α] {ι : Sort u_5}
[Countable ι] {f : ι → δ → α} {g : δ → α},
(∀ (i : ι), Measurable (f i)) → (∀ (b : δ), IsGLB {a | ∃ i, f i b = a} (g b)) → Measurable g |
ONote.cmp._sunfold | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote → Ordering |
Int.sign.eq_3 | Init.Data.Int.Order | ∀ (a : ℕ), (Int.negSucc a).sign = -1 |
CategoryTheory.MonoidalCategory.MonoidalRightAction._aux_Mathlib_CategoryTheory_Monoidal_Action_Basic___unexpand_CategoryTheory_MonoidalCategory_MonoidalRightActionStruct_actionUnitIso_2 | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.PrettyPrinter.Unexpander |
PSigma.noConfusionType | Init.Core | Sort u_1 → {α : Sort u} → {β : α → Sort v} → PSigma β → {α' : Sort u} → {β' : α' → Sort v} → PSigma β' → Sort u_1 |
_private.Init.Data.UInt.Lemmas.0.UInt16.toUInt8_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) |
Nonneg.coe_nsmul._simp_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : AddMonoid α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] (n : ℕ) (a : { x // 0 ≤ x }),
n • ↑a = ↑(n • a) |
CategoryTheory.Limits.IsCofiltered.sequentialFunctor_initial_aux | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ (J : Type u_2) [inst : Countable J] [inst_1 : Preorder J] [inst_2 : CategoryTheory.IsCofiltered J] (j : J),
∃ n, CategoryTheory.Limits.IsCofiltered.sequentialFunctor_obj J n ≤ j |
SemilatticeSup.le_sup_left | Mathlib.Order.Lattice | ∀ {α : Type u} [self : SemilatticeSup α] (a b : α), a ≤ SemilatticeSup.sup a b |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.exists_mem_isCircuit_of_not_isColoop._simp_1_2 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
NonUnitalSubsemiring.eq_top_iff' | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (A : NonUnitalSubsemiring R), A = ⊤ ↔ ∀ (x : R), x ∈ A |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.IsPrimitiveRoot.arg._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioc a b) = (a < x ∧ x ≤ b) |
OreLocalization.universalHom._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_2} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {T : Type u_1}
[inst_2 : Semiring T] (f : R →+* T) (fS : ↥S →* Tˣ) (hf : ∀ (s : ↥S), f ↑s = ↑(fS s)) (x y : OreLocalization S R),
(↑(OreLocalization.universalMulHom (↑f) fS hf)).toFun (x + y) =
(↑(OreLocalization.universalMulHom (↑f) fS hf)).toFun x + (↑(OreLocalization.universalMulHom (↑f) fS hf)).toFun y |
PolynomialLaw.instZero | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {N : Type u_2} → [inst_3 : AddCommMonoid N] → [inst_4 : Module R N] → Zero (M →ₚₗ[R] N) |
Order.PFilter.IsPrime.rec | Mathlib.Order.PrimeIdeal | {P : Type u_1} →
[inst : Preorder P] →
{F : Order.PFilter P} →
{motive : F.IsPrime → Sort u} → ((compl_ideal : Order.IsIdeal (↑F)ᶜ) → motive ⋯) → (t : F.IsPrime) → motive t |
_private.Mathlib.RingTheory.Smooth.Basic.0.Algebra.FormallySmooth.iff_split_injection._simp_1_1 | Mathlib.RingTheory.Smooth.Basic | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
{f g : M →ₛₗ[σ] M₃}, (f = g) = ∀ (x : M), f x = g x |
toColex | Mathlib.Order.Lex | {α : Type u_1} → α ≃ Colex α |
IntermediateField.inclusion_injective | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {E F : IntermediateField K L}
(hEF : E ≤ F), Function.Injective ⇑(IntermediateField.inclusion hEF) |
IsSelfAdjoint.add_star_self | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : StarAddMonoid R] (x : R), IsSelfAdjoint (x + star x) |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile.0.Std.IterM.step_takeWhileWithPostcondition.match_1.splitter | Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} →
(out : β) →
(motive : Subtype (P out).Property → Sort u_3) →
(__do_lift : Subtype (P out).Property) →
((h' : (P out).Property { down := true }) → motive ⟨{ down := true }, h'⟩) →
((h' : (P out).Property { down := false }) → motive ⟨{ down := false }, h'⟩) → motive __do_lift |
AddCommMonCat.instCoeMonCat | Mathlib.Algebra.Category.MonCat.Basic | Coe AddCommMonCat AddMonCat |
_private.Mathlib.Algebra.Order.Disjointed.0.partialSups_add_one_eq_sup_disjointed._simp_1_3 | Mathlib.Algebra.Order.Disjointed | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, (a \ b ≤ c) = (a ≤ b ⊔ c) |
SetRel.IsCover.mono_entourage | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {U V : SetRel X X} {s N : Set X}, U ⊆ V → U.IsCover s N → V.IsCover s N |
CategoryTheory.ShrinkHoms.equivalence._proof_4 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{u_2, u_3, u_1} C]
{X Y : CategoryTheory.ShrinkHoms.{u_1} C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ShrinkHoms.inverse C).comp (CategoryTheory.ShrinkHoms.functor C)).map f)
((fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.ShrinkHoms.inverse C).comp (CategoryTheory.ShrinkHoms.functor C)).obj x))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.ShrinkHoms.inverse C).comp (CategoryTheory.ShrinkHoms.functor C)).obj x))
X).hom
((CategoryTheory.Functor.id (CategoryTheory.ShrinkHoms.{u_1} C)).map f) |
Lean.Elab.Command.Structure.StructFieldKind.copiedField | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructFieldKind |
PowerSeries.evalNegHom | Mathlib.RingTheory.PowerSeries.Basic | {A : Type u_2} → [inst : CommRing A] → PowerSeries A →+* PowerSeries A |
Std.DTreeMap.Internal.instIteratorRxoIteratorIdSigma._proof_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (it : Std.IterM Id ((a : α) × β a)),
it.internalState.step = it.internalState.step |
Set.mulIndicator_self_mul_compl_apply | Mathlib.Algebra.Group.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : MulOneClass M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a * sᶜ.mulIndicator f a = f a |
Std.DHashMap.Raw.isEmpty_iff_forall_not_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → (m.isEmpty = true ↔ ∀ (a : α), a ∉ m) |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.Context.ctorIdx | Lean.Compiler.LCNF.Specialize | Lean.Compiler.LCNF.Specialize.Context✝ → ℕ |
Lean.Elab.Command.InductiveElabStep2.noConfusionType | Lean.Elab.MutualInductive | Sort u → Lean.Elab.Command.InductiveElabStep2 → Lean.Elab.Command.InductiveElabStep2 → Sort u |
SimpleGraph.Walk.instDecidableNil._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (w v_1 : V) (h : G.Adj v v_1) (p : G.Walk v_1 w),
(SimpleGraph.Walk.cons h p).Nil → False |
SemimoduleCat.Hom.hom₂_apply | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ {R : Type u_1} [inst : CommSemiring R] {M N P : SemimoduleCat R} (f : M ⟶ SemimoduleCat.of R (N ⟶ P)) (a : ↑M),
(SemimoduleCat.Hom.hom₂ f) a = (SemimoduleCat.ofHom ↑SemimoduleCat.homLinearEquiv).hom' (f.hom' a) |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_4 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {F : Type u_1} [inst : AddCommGroup F] [inst_1 : TopologicalSpace F] [IsTopologicalAddGroup F], ContinuousAdd F |
AddMagmaCat.instConcreteCategoryAddHomCarrier._proof_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : AddMagmaCat} (f : ↑X →ₙ+ ↑Y), { hom' := f }.hom' = f |
CompactlySupportedContinuousMap.instAddCommMonoidOfContinuousAdd._proof_3 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddCommMonoid β]
[inst_3 : ContinuousAdd β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g |
Lean.Lsp.LeanClientCapabilities | Lean.Data.Lsp.Capabilities | Type |
Set.prod_eq_prod_iff_of_nonempty | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}, (s ×ˢ t).Nonempty → (s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁) |
Std.DTreeMap.Internal.Impl.WF.union | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t₁ : Std.DTreeMap.Internal.Impl α β} {h₁ : t₁.WF}
{t₂ : Std.DTreeMap.Internal.Impl α β} {h₂ : t₂.WF}, (t₁.union t₂ ⋯ ⋯).WF |
Polynomial.separable_def | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] (f : Polynomial R), f.Separable ↔ IsCoprime f (Polynomial.derivative f) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.