name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
QuotientGroup.quotientMulEquivOfEq.congr_simp | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {G : Type u} [inst : Group G] {M N : Subgroup G} [inst_1 : M.Normal] [inst_2 : N.Normal] (h : M = N),
QuotientGroup.quotientMulEquivOfEq h = QuotientGroup.quotientMulEquivOfEq h |
Std.TreeMap.getKey?_maxKeyD | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback : α}, t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback) |
Std.ExtHashSet.get?_ofList_of_mem | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.ExtHashSet.ofList l).get? k' = some k |
CategoryTheory.ShortComplex.π₂Toπ₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
CategoryTheory.ShortComplex.π₂ ⟶ CategoryTheory.ShortComplex.π₃ |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse.0.Real.cosPartialHomeomorph._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ ⦃x_1 : ℝ⦄, x_1 ∈ Set.Ioo 0 Real.pi → Real.cos x_1 ∈ Set.Ioo (-1) 1 |
MeasurableSet.sInter | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : Set (Set α)},
s.Countable → (∀ t ∈ s, MeasurableSet t) → MeasurableSet (⋂₀ s) |
Array.scanlM_reverse | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {init : β} [inst : Monad m] [LawfulMonad m] {f : β → α → m β}
{as : Array α}, Array.scanlM f init as.reverse = Array.reverse <$> Array.scanrM (flip f) init as |
CommGrpCat.hasForgetToGroup.eq_1 | Mathlib.Algebra.Category.Grp.Basic | CommGrpCat.hasForgetToGroup =
{
forget₂ :=
{ obj := fun X => GrpCat.of ↑X, map := fun {X Y} f => GrpCat.ofHom (CommGrpCat.Hom.hom f),
map_id := CommGrpCat.hasForgetToGroup._proof_1, map_comp := @CommGrpCat.hasForgetToGroup._proof_2 },
forget_comp := CommGrpCat.hasForgetToGroup._proof_4 } |
_private.Mathlib.Data.Set.Lattice.0.Set.iUnion_image_preimage_sigma_mk_eq_self._simp_1_2 | Mathlib.Data.Set.Lattice | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
CategoryTheory.SmallObject.SuccStruct.ofCocone_obj_eq_pt._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.FunctorOfCocone | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J}, j ∈ Set.Iic j |
Std.BundledIterM._sizeOf_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} → {β : Type w} → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → Std.BundledIterM m β → ℕ |
CircularPartialOrder.mk.noConfusion | Mathlib.Order.Circular | {α : Type u_1} →
{P : Sort u} →
{toCircularPreorder : CircularPreorder α} →
{btw_antisymm : ∀ {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a} →
{toCircularPreorder' : CircularPreorder α} →
{btw_antisymm' : ∀ {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a} →
{ toCircularPreorder := toCircularPreorder, btw_antisymm := btw_antisymm } =
{ toCircularPreorder := toCircularPreorder', btw_antisymm := btw_antisymm' } →
(toCircularPreorder ≍ toCircularPreorder' → P) → P |
Lean.Meta.Sym.Simp.EvalStepConfig.noConfusionType | Lean.Meta.Sym.Simp.EvalGround | Sort u → Lean.Meta.Sym.Simp.EvalStepConfig → Lean.Meta.Sym.Simp.EvalStepConfig → Sort u |
_private.Mathlib.Analysis.Calculus.Rademacher.0.LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul'._simp_1_1 | Mathlib.Analysis.Calculus.Rademacher | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
ModuleCat.image | Mathlib.Algebra.Category.ModuleCat.Images | {R : Type u} → [inst : Ring R] → {G H : ModuleCat R} → (G ⟶ H) → ModuleCat R |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.findStructCtorInfo?._sparseCasesOn_6 | Lean.Compiler.LCNF.StructProjCases | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
String.Slice.Pos.instLinearOrderPackage._proof_8 | Init.Data.String.OrderInstances | ∀ {s : String.Slice},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Min.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊓ b = if a ≤ b then a else b |
Bool.toUInt16 | Init.Data.UInt.Basic | Bool → UInt16 |
_private.Mathlib.ModelTheory.Algebra.Field.IsAlgClosed.0.FirstOrder.Field.instModelACFOfCharPOfIsAlgClosed._simp_3 | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
AlgebraicGeometry.Scheme.IdealSheafData.gci._proof_5 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (x : X.IdealSheafData), sSup {J | J.ideal ≤ x.ideal} ≤ x |
AlgEquiv.coe_apply_coe_coe_symm_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {F : Type u_1} [inst_5 : EquivLike F A₁ A₂]
[inst_6 : AlgEquivClass F R A₁ A₂] (f : F) (x : A₂), f ((↑f).symm x) = x |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology._proof_15 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X],
∀ s ∈ {P | P ⊆ constructibleTopologySubbasis X ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅},
∀ (B : Set (Set X)) (Y₁ Y₂ : Set X),
⋂₀ {s | s ∈ B ∧ IsClosed s} ⊆ Y₁ ∪ Y₂ →
∀ x₁ ∈ ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ Y₁ᶜ,
∀ x₂ ∈ ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ Y₂ᶜ,
Y₁ ∩ ⋂₀ B = ∅ →
Y₂ ∩ ⋂₀ B = ∅ →
∀ (A₁ : Set (Set X)),
⋂₀ A₁ = ∅ →
∀ (A₂ : Set (Set X)), ⋂₀ A₂ = ∅ → ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ ⋂₀ (A₁ \ {Y₁} ∪ A₂ \ {Y₂}) = ∅ |
Matrix.toLinAlgEquiv_mul | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_4} [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M₁ : Type u_5}
[inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] (v₁ : Module.Basis n R M₁) (A B : Matrix n n R),
(Matrix.toLinAlgEquiv v₁) (A * B) = (Matrix.toLinAlgEquiv v₁) A ∘ₗ (Matrix.toLinAlgEquiv v₁) B |
MeasurableSet.disjointed | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : ℕ → Set α},
(∀ (i : ℕ), MeasurableSet (f i)) → ∀ (n : ℕ), MeasurableSet (disjointed f n) |
IsCyclotomicExtension.Rat.isPrime_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
(Ideal.span {hζ.toInteger - 1}).IsPrime |
IntermediateField.fintypeOfAlgHomAdjoinIntegral | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | (F : Type u_1) →
[inst : Field F] →
{E : Type u_2} →
[inst_1 : Field E] →
[inst_2 : Algebra F E] →
{α : E} →
{K : Type u} → [inst_3 : Field K] → [inst_4 : Algebra F K] → IsIntegral F α → Fintype (↥F⟮α⟯ →ₐ[F] K) |
Std.DTreeMap.Internal.Const.RccSliceData._sizeOf_1 | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} → {inst : Ord α} → [SizeOf α] → [SizeOf β] → Std.DTreeMap.Internal.Const.RccSliceData α β → ℕ |
LieModuleHom.mk | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
[inst_6 : LieRingModule L M] →
[inst_7 : LieRingModule L N] →
(toLinearMap : M →ₗ[R] N) →
(∀ {x : L} {m : M}, toLinearMap.toFun ⁅x, m⁆ = ⁅x, toLinearMap.toFun m⁆) → M →ₗ⁅R,L⁆ N |
Rat.zero_num | Init.Data.Rat.Lemmas | Rat.num 0 = 0 |
Polynomial.leadingCoeff_map_of_leadingCoeff_ne_zero | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {p : Polynomial R} (f : R →+* S),
f p.leadingCoeff ≠ 0 → (Polynomial.map f p).leadingCoeff = f p.leadingCoeff |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.subgraphOfAdj_symm._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.thunk.noConfusion | Batteries.Data.MLList.Basic | {m : Type u → Type u} →
{α : Type u} →
{P : Sort u_1} →
{a a' : Thunk (MLList.MLListImpl✝ m α)} →
MLList.MLListImpl.thunk✝ a = MLList.MLListImpl.thunk✝¹ a' → (a ≍ a' → P) → P |
Set.zero_mem_sub_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∈ s - t ↔ ¬Disjoint s t |
ValuationSubring.instSemilatticeSup._proof_3 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (R S : ValuationSubring K), ∀ x ∈ S, x ∈ R.toSubring ⊔ S.toSubring |
_private.Init.Data.List.Impl.0.List.takeWhileTR.go._sunfold | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α |
Mathlib.Tactic.Linarith.SimplexAlgorithm.checkSuccess | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {matType : ℕ → ℕ → Type} →
[inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Bool |
CategoryTheory.PreOneHypercover.Homotopy.wl | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F} (self : CategoryTheory.PreOneHypercover.Homotopy f g)
(i : E.I₀), CategoryTheory.CategoryStruct.comp (self.a i) (F.p₁ (self.H i)) = f.h₀ i |
LSeriesSummable_congr' | Mathlib.NumberTheory.LSeries.Basic | ∀ {f g : ℕ → ℂ} (s : ℂ), f =ᶠ[Filter.atTop] g → (LSeriesSummable f s ↔ LSeriesSummable g s) |
AlgebraicTopology.DoldKan.Γ₀.Obj.obj₂._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ) [CategoryTheory.Limits.HasFiniteCoproducts C],
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor fun A => AlgebraicTopology.DoldKan.Γ₀.Obj.summand K Δ A) |
_private.Mathlib.Order.UpperLower.Relative.0.isRelLowerSet_Icc_ge._simp_1_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) |
Lean.Lsp.instFromJsonCodeActionContext | Lean.Data.Lsp.CodeActions | Lean.FromJson Lean.Lsp.CodeActionContext |
Algebra.PreSubmersivePresentation.differential._proof_1 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_2} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ),
RingHomInvPair (RingHom.id P.Ring) (RingHom.id P.Ring) |
CommRingCat.moduleCatExtendScalarsPseudofunctor._proof_6 | Mathlib.Algebra.Category.ModuleCat.Pseudofunctor | ∀ {b₀ b₁ : CommRingCat} (f : b₀ ⟶ b₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Cat.Hom.isoMk
(ModuleCat.extendScalarsComp (CommRingCat.Hom.hom f)
(CommRingCat.Hom.hom (CategoryTheory.CategoryStruct.id b₁)))).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (ModuleCat.extendScalars (CommRingCat.Hom.hom f)).toCatHom
(CategoryTheory.Cat.Hom.isoMk (ModuleCat.extendScalarsId ↑b₁)).hom)
(CategoryTheory.Bicategory.rightUnitor (ModuleCat.extendScalars (CommRingCat.Hom.hom f)).toCatHom).hom) =
CategoryTheory.eqToHom ⋯ |
Batteries.RBNode.instIsStrictCut | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (cmp : α → α → Ordering) (a : α), Batteries.RBNode.IsStrictCut cmp (cmp a) |
Unitary.instMulActionSubtypeMemSubmonoidUnitary._proof_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : Monoid A] [inst_2 : MulAction R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] [inst_5 : StarMul R] [inst_6 : StarMul A]
[inst_7 : StarModule R A] (x x_1 : ↥(unitary R)) (x_2 : ↥(unitary A)), (x * x_1) • x_2 = x • x_1 • x_2 |
Lean.Lsp.instToJsonClientCapabilities.toJson | Lean.Data.Lsp.Capabilities | Lean.Lsp.ClientCapabilities → Lean.Json |
Set.principalSegIioIicOfLE._proof_2 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] {i j : α} (h : i ≤ j) (x x_1 : ↑(Set.Iio i)),
(fun x =>
match x with
| ⟨k, hk⟩ => ⟨k, ⋯⟩)
x =
(fun x =>
match x with
| ⟨k, hk⟩ => ⟨k, ⋯⟩)
x_1 →
x = x_1 |
instIdempotentOpInt64HAnd | Init.Data.SInt.Bitwise | Std.IdempotentOp fun x1 x2 => x1 &&& x2 |
Std.Iter.toList_takeWhile_of_finite | Std.Data.Iterators.Lemmas.Combinators.TakeWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {P : β → Bool} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.takeWhile P it).toList = List.takeWhile P it.toList |
Measurable.of_uncurry_right | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
{f : α → β → γ}, Measurable (Function.uncurry f) → ∀ {y : β}, Measurable fun x => f x y |
QuotientAddGroup.orbit_mk_eq_vadd | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (x : α), AddAction.orbitRel.Quotient.orbit ↑x = x +ᵥ ↑s |
DividedPowers.ofInjective._proof_5 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B),
Function.Injective ⇑f →
∀ (hJ : DividedPowers J),
Ideal.map f I = J →
∀ (hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {n : ℕ} {x y : A},
x ∈ I →
y ∈ I →
(if hx : x + y ∈ I then ⋯.choose else 0) =
∑ k ∈ Finset.antidiagonal n, (if hx : x ∈ I then ⋯.choose else 0) * if hx : y ∈ I then ⋯.choose else 0 |
IdealFilter.isPFilter_gabrielComposition | Mathlib.RingTheory.IdealFilter.Basic | ∀ {A : Type u_1} [inst : Ring A] (F G : IdealFilter A), Order.IsPFilter {L | ∃ K ∈ G, F.IsTorsionQuot L K} |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.Iterators.Types.Attach.Monadic.modifyStep.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {P : β → Prop}
(it : Std.IterM m { out // P out }) (motive : it.internalState.inner.Step → Sort u_3) (it' : Std.IterM m β)
(h : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.IterM m β) →
(out : β) →
(h : it.internalState.inner.IsPlausibleStep (Std.IterStep.yield it' out)) →
motive ⟨Std.IterStep.yield it' out, h⟩)
(h_2 :
(it' : Std.IterM m β) →
(h : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩)
(h_3 : (property : it.internalState.inner.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, property⟩),
(match ⟨Std.IterStep.skip it', h⟩ with
| ⟨Std.IterStep.yield it' out, h⟩ => h_1 it' out h
| ⟨Std.IterStep.skip it', h⟩ => h_2 it' h
| ⟨Std.IterStep.done, property⟩ => h_3 property) =
h_2 it' h |
_private.Mathlib.Analysis.Normed.Order.Lattice.0.Int.hasSolidNorm._simp_1 | Mathlib.Analysis.Normed.Order.Lattice | ∀ (m : ℤ), ‖m‖ = ‖↑m‖ |
Std.DTreeMap.Const.get?_inter_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α}, k ∉ t₂ → Std.DTreeMap.Const.get? (t₁ ∩ t₂) k = none |
ArchimedeanClass.lt_of_lt_stdPart | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x : K} (f : ℝ →+*o K) {r : ℝ},
0 ≤ ArchimedeanClass.mk x → r < ArchimedeanClass.stdPart x → f r < x |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Mon.mul.go.match_1.eq_2 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Sort u_1) (m₂ : Lean.Grind.CommRing.Mon)
(h_1 : (m₁ : Lean.Grind.CommRing.Mon) → motive m₁ Lean.Grind.CommRing.Mon.unit)
(h_2 : (m₂ : Lean.Grind.CommRing.Mon) → motive Lean.Grind.CommRing.Mon.unit m₂)
(h_3 :
(pw₁ : Lean.Grind.CommRing.Power) →
(m₁ : Lean.Grind.CommRing.Mon) →
(pw₂ : Lean.Grind.CommRing.Power) →
(m₂ : Lean.Grind.CommRing.Mon) →
motive (Lean.Grind.CommRing.Mon.mult pw₁ m₁) (Lean.Grind.CommRing.Mon.mult pw₂ m₂)),
(m₂ = Lean.Grind.CommRing.Mon.unit → False) →
(match Lean.Grind.CommRing.Mon.unit, m₂ with
| m₁, Lean.Grind.CommRing.Mon.unit => h_1 m₁
| Lean.Grind.CommRing.Mon.unit, m₂ => h_2 m₂
| Lean.Grind.CommRing.Mon.mult pw₁ m₁, Lean.Grind.CommRing.Mon.mult pw₂ m₂ => h_3 pw₁ m₁ pw₂ m₂) =
h_2 m₂ |
TopCat.toCondensedSet._proof_1 | Mathlib.Condensed.TopComparison | ∀ (x x_1 : CompHausLike fun x => True) (x_2 : x ⟶ x_1),
[CategoryTheory.EffectiveEpi x_2, CategoryTheory.Epi x_2,
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom x_2)][0]? =
some (CategoryTheory.EffectiveEpi x_2) |
CategoryTheory.Limits.BinaryBicone.toCocone_ι_app_right | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q),
c.toCocone.ι.app { as := CategoryTheory.Limits.WalkingPair.right } = c.inr |
Lean.Meta.Grind.Arith.Linear.State.exprToNatStructId._default | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr ℕ |
Std.RecursiveMutex.tryAtomically | Std.Sync.RecursiveMutex | {m : Type → Type} →
{α β : Type} →
[Monad m] → [MonadLiftT BaseIO m] → [MonadFinally m] → Std.RecursiveMutex α → Std.AtomicT α m β → m (Option β) |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_2 | Mathlib.Analysis.Analytic.Composition | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) |
CategoryTheory.Triangulated.TStructure.triangleLEGT_obj_obj₂ | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {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]
(t : CategoryTheory.Triangulated.TStructure C) (n : ℤ) (j : C), ((t.triangleLEGT n).obj j).obj₂ = j |
Lean.CodeAction.CommandCodeActionEntry.mk.inj | Lean.Server.CodeActions.Attr | ∀ {declName : Lean.Name} {cmdKinds : Array Lean.Name} {declName_1 : Lean.Name} {cmdKinds_1 : Array Lean.Name},
{ declName := declName, cmdKinds := cmdKinds } = { declName := declName_1, cmdKinds := cmdKinds_1 } →
declName = declName_1 ∧ cmdKinds = cmdKinds_1 |
ForInStep.yield.elim | Init.Core | {α : Type u} →
{motive : ForInStep α → Sort u_1} →
(t : ForInStep α) → t.ctorIdx = 1 → ((a : α) → motive (ForInStep.yield a)) → motive t |
Multiplicative.mem_toSubgroup._simp_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {A : Type u_2} [inst : AddGroup A] (S : AddSubgroup A) (a : Multiplicative A),
(a ∈ AddSubgroup.toSubgroup S) = (Multiplicative.toAdd a ∈ S) |
Lean.Meta.Hint.Suggestion.previewSpan? | Lean.Meta.Hint | Lean.Meta.Hint.Suggestion → Option Lean.Syntax |
Ordering.isLT_iff_eq_lt | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.isLT = true ↔ o = Ordering.lt |
CategoryTheory.Precoverage.IsStableUnderSup.recOn | Mathlib.CategoryTheory.Sites.Precoverage | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{motive : J.IsStableUnderSup → Sort u_1} →
(t : J.IsStableUnderSup) →
((sup_mem_coverings :
∀ {X : C} {R S : CategoryTheory.Presieve X},
R ∈ J.coverings X → S ∈ J.coverings X → R ⊔ S ∈ J.coverings X) →
motive ⋯) →
motive t |
Profinite.Extend.cocone_pt | Mathlib.Topology.Category.Profinite.Extend | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (G : CategoryTheory.Functor Profiniteᵒᵖ C)
(S : Profinite), (Profinite.Extend.cocone G S).pt = G.obj (Opposite.op S) |
HomologicalComplex₂.d_comm_assoc | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂)
(i₁ i₁' : I₁) (i₂ i₂' : I₂) {Z : C} (h : (K.X i₁').X i₂' ⟶ Z),
CategoryTheory.CategoryStruct.comp ((K.d i₁ i₁').f i₂) (CategoryTheory.CategoryStruct.comp ((K.X i₁').d i₂ i₂') h) =
CategoryTheory.CategoryStruct.comp ((K.X i₁).d i₂ i₂') (CategoryTheory.CategoryStruct.comp ((K.d i₁ i₁').f i₂') h) |
Unitization.antilipschitzWith_addEquiv | Mathlib.Analysis.Normed.Algebra.Unitization | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : IsScalarTower 𝕜 A A] [inst_4 : SMulCommClass 𝕜 A A]
[inst_5 : RegularNormedAlgebra 𝕜 A], AntilipschitzWith 2 ⇑(Unitization.addEquiv 𝕜 A) |
StarAlgEquiv.mul_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f g : R ≃⋆ₐ[S] R)
(x : R), (f * g) x = f (g x) |
Turing.PartrecToTM2.trLList.eq_def | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : List (List ℕ)),
Turing.PartrecToTM2.trLList x =
match x with
| [] => []
| l :: ls => Turing.PartrecToTM2.trList l ++ Turing.PartrecToTM2.Γ'.consₗ :: Turing.PartrecToTM2.trLList ls |
SimpleGraph.eq_top_of_chromaticNumber_eq_card | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber = ↑(Fintype.card V) → G = ⊤ |
_private.Mathlib.RingTheory.LocalRing.RingHom.Basic.0.IsLocalRing.instIsLocalHomRingHomOfNontrivial._simp_1 | Mathlib.RingTheory.LocalRing.RingHom.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0) |
SSet.Truncated.Path₁.vertex | Mathlib.AlgebraicTopology.SimplicialSet.Path | {X : SSet.Truncated 1} →
{n : ℕ} →
X.Path₁ n →
Fin (n + 1) → X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Path₁._proof_1 }) |
Int.map_add_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n k : ℤ}, Array.map (fun x => x + k) (m<...n).toArray = ((m + k)<...n + k).toArray |
Lean.IR.EmitC.Context.recOn | Lean.Compiler.IR.EmitC | {motive : Lean.IR.EmitC.Context → Sort u} →
(t : Lean.IR.EmitC.Context) →
((env : Lean.Environment) →
(modName : Lean.Name) →
(jpMap : Lean.IR.JPParamsMap) →
(mainFn : Lean.IR.FunId) →
(mainParams : Array Lean.IR.Param) →
motive { env := env, modName := modName, jpMap := jpMap, mainFn := mainFn, mainParams := mainParams }) →
motive t |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.subst.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {x : Lean.Grind.Linarith.Var} {c₁ : Lean.Meta.Grind.Arith.Linear.EqCnstr}
{c₂ : Lean.Meta.Grind.Arith.Linear.IneqCnstr} {x_1 : Lean.Grind.Linarith.Var}
{c₁_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr} {c₂_1 : Lean.Meta.Grind.Arith.Linear.IneqCnstr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.subst x c₁ c₂ =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.subst x_1 c₁_1 c₂_1 →
x = x_1 ∧ c₁ = c₁_1 ∧ c₂ = c₂_1 |
Field.span_map_pow_expChar_pow_eq_top_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (q n : ℕ) [hF : ExpChar F q]
{ι : Type u_1} {v : ι → E} [Algebra.IsSeparable F E],
Submodule.span F (Set.range v) = ⊤ → Submodule.span F (Set.range fun x => v x ^ q ^ n) = ⊤ |
Projectivization.orthogonal._proof_4 | Mathlib.LinearAlgebra.Projectivization.Constructions | ∀ {F : Type u_1} [inst : Field F] {m : Type u_2} [inst_1 : Fintype m] (x x_1 x_2 x_3 : { v // v ≠ 0 }) (w : Fˣ),
(fun m_1 => m_1 • ↑x_2) w = ↑x →
∀ (w : Fˣ), (fun m_1 => m_1 • ↑x_3) w = ↑x_1 → (fun v w => ↑v ⬝ᵥ ↑w = 0) x x_1 = (fun v w => ↑v ⬝ᵥ ↑w = 0) x_2 x_3 |
localCohomology.ofSelfLERadical | Mathlib.Algebra.Homology.LocalCohomology | {R : Type u} → [inst : CommRing R] → Ideal R → ℕ → CategoryTheory.Functor (ModuleCat R) (ModuleCat R) |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.mulActionHom_compl._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {s : Finset β}
{a : α} {b : β}, (b ∈ a • s) = (a⁻¹ • b ∈ s) |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftUnitor_actionHom._autoParam | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.Syntax |
CategoryTheory.ShortComplex.isIso_leftHomologyπ | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology], S.f = 0 → CategoryTheory.IsIso S.leftHomologyπ |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.Lean.Meta.Grind.isMatchCondFalseHyp | Lean.Meta.Tactic.Grind.MatchCond | Lean.Expr → Lean.Meta.Grind.GoalM Bool |
ContinuousLinearEquiv.automorphismGroup._proof_4 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} [inst : Semiring R₁] (M₁ : Type u_2) [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (a : M₁ ≃L[R₁] M₁), zpowRec npowRec 0 a = 1 |
Homeomorph.toMeasurableEquiv_coe | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {γ : Type u_3} {γ₂ : Type u_4} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [inst_2 : BorelSpace γ]
[inst_3 : TopologicalSpace γ₂] [inst_4 : MeasurableSpace γ₂] [inst_5 : BorelSpace γ₂] (h : γ ≃ₜ γ₂),
⇑h.toMeasurableEquiv = ⇑h |
RingHom.IsStandardOpenImmersion.containsIdentities | Mathlib.RingTheory.RingHom.OpenImmersion | RingHom.ContainsIdentities fun {R S} [CommRing R] [CommRing S] => RingHom.IsStandardOpenImmersion |
Pi.seminormedRing._proof_15 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedRing (R i)] (n : ℕ)
(a : (i : ι) → R i), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.evalLT.match_1 | Mathlib.Tactic.Ring.Compare | {v : Lean.Level} →
{α : Q(Type v)} →
(lα : Q(LT «$α»)) →
(xa xb : Q(«$α»)) →
(motive : Mathlib.Meta.NormNum.Result q(«$xa» < «$xb») → Sort u_1) →
(__discr : Mathlib.Meta.NormNum.Result q(«$xa» < «$xb»)) →
((pf : Q(«$xa» < «$xb»)) → motive (Mathlib.Meta.NormNum.Result'.isBool true pf)) →
((x : Mathlib.Meta.NormNum.Result q(«$xa» < «$xb»)) → motive x) → motive __discr |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.activateTheoremsCore | Lean.Meta.Tactic.Grind.Internalize | {α : Type} →
[Lean.Meta.Grind.TheoremLike α] →
Lean.Name →
Lean.Meta.Grind.GoalM (Lean.Meta.Grind.TheoremsArray α) →
(Lean.Meta.Grind.TheoremsArray α → Lean.Meta.Grind.GoalM Unit) →
(α → Lean.Meta.Grind.GoalM Unit) → (α → Lean.Meta.Grind.GoalM Unit) → Lean.Meta.Grind.GoalM Unit |
CategoryTheory.Subobject.inf_pullback | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X Y : C}
(g : X ⟶ Y) (f₁ f₂ : CategoryTheory.Subobject Y),
(CategoryTheory.Subobject.pullback g).obj (f₁ ⊓ f₂) =
(CategoryTheory.Subobject.pullback g).obj f₁ ⊓ (CategoryTheory.Subobject.pullback g).obj f₂ |
_private.Lean.Meta.Sym.Apply.0.Lean.Meta.Sym.mkResultPos | Lean.Meta.Sym.Apply | Lean.Meta.Sym.Pattern → List ℕ |
CategoryTheory.IsPullback.isLimitFork._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Y} {g g' : Y ⟶ Z},
CategoryTheory.IsPullback f f g g' → CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f g' |
IntermediateField.Lifts.le_union | Mathlib.FieldTheory.Extension | ∀ {F : Type u_1} {E : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] (c : Set (IntermediateField.Lifts F E K))
(hc : IsChain (fun x1 x2 => x1 ≤ x2) c) ⦃σ : IntermediateField.Lifts F E K⦄,
σ ∈ c → σ ≤ IntermediateField.Lifts.union c hc |
ProperCone.map_id | Mathlib.Analysis.Convex.Cone.Basic | ∀ {R : Type u_2} {F : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid F] [inst_4 : TopologicalSpace F] [inst_5 : Module R F] [inst_6 : ContinuousAdd F]
[inst_7 : ContinuousConstSMul R F] (C : ProperCone R F), ProperCone.map (ContinuousLinearMap.id R F) C = C |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.