name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Batteries.AssocList.findEntryP?._unsafe_rec | Batteries.Data.AssocList | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → Batteries.AssocList α β → Option (α × β) |
not_fermatLastTheoremFor_two | Mathlib.NumberTheory.FLT.Basic | ¬FermatLastTheoremFor 2 |
FreeLieAlgebra.liftAux_map_mul | Mathlib.Algebra.Lie.Free | ∀ (R : Type u) {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(a b : FreeNonUnitalNonAssocAlgebra R X),
(FreeLieAlgebra.liftAux R f) (a * b) = ⁅(FreeLieAlgebra.liftAux R f) a, (FreeLieAlgebra.liftAux R f) b⁆ |
selfAdjointPart_apply_coe | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) {A : Type u_2} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x : A), ↑((selfAdjointPart R) x) = ⅟2 • (x + star x) |
Set.uIoo_subset_Ioo | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
a₁ ∈ Set.Icc a₂ b₂ → b₁ ∈ Set.Icc a₂ b₂ → Set.uIoo a₁ b₁ ⊆ Set.Ioo a₂ b₂ |
AddSubgroup.unop_injective | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_2} [inst : AddGroup G], Function.Injective AddSubgroup.unop |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Level) → motive a.succ) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.valuedCompletion_surjective_iff._simp_1_1 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) |
List.flatten_nil | Init.Data.List.Basic | ∀ {α : Type u}, [].flatten = [] |
CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf_obj_a | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(V : CategoryTheory.Endofunctor.Coalgebra G),
((CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf adj).obj V).a = V.V |
Submodule.mul_iSup | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {ι : Sort uι} (t : Submodule R A) (s : ι → Submodule R A), t * ⨆ i, s i = ⨆ i, t * s i |
Finset.univ_val_map_subtype_restrict | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] (f : α → β) (p : α → Prop) [inst_1 : DecidablePred p]
[inst_2 : Fintype { a // p a }],
Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val |
Nat.orderEmbeddingOfSet_range | Mathlib.Order.OrderIsoNat | ∀ (s : Set ℕ) [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s], Set.range ⇑(Nat.orderEmbeddingOfSet s) = s |
Filter.HasBasis.forall_mem_mem | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ∀ {x : α}, (∀ t ∈ l, x ∈ t) ↔ ∀ (i : ι), p i → x ∈ s i |
HasCompactMulSupport.uniformContinuous_of_continuous | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} [inst_2 : One β],
HasCompactMulSupport f → Continuous f → UniformContinuous f |
PresheafOfModules.sections.eval | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → {M : PresheafOfModules R} → M.sections → (X : Cᵒᵖ) → ↑(M.obj X) |
Lean.OptionDecl.mk.injEq | Lean.Data.Options | ∀ (name : Lean.Name) (declName : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue : Lean.DataValue)
(descr : String) (name_1 : Lean.Name) (declName_1 : autoParam Lean.Name Lean.OptionDecl.declName._autoParam)
(defValue_1 : Lean.DataValue) (descr_1 : String),
({ name := name, declName := declName, defValue := defValue, descr := descr } =
{ name := name_1, declName := declName_1, defValue := defValue_1, descr := descr_1 }) =
(name = name_1 ∧ declName = declName_1 ∧ defValue = defValue_1 ∧ descr = descr_1) |
Cardinal.zero_lt_lift_iff | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{u}}, 0 < Cardinal.lift.{v, u} a ↔ 0 < a |
Lean.Lsp.SymbolKind.boolean | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind |
Cube.insertAt_boundary | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : DecidableEq N] (i : N) {t₀ : ↑unitInterval} {t : { j // j ≠ i } → ↑unitInterval},
(t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i } → (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N |
CategoryTheory.Limits.Cofork.π.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g),
t.π = t.ι.app CategoryTheory.Limits.WalkingParallelPair.one |
Std.Iterators.Types.DropWhile.recOn | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} →
{motive : Std.Iterators.Types.DropWhile α m β P → Sort u} →
(t : Std.Iterators.Types.DropWhile α m β P) →
((dropping : Bool) → (inner : Std.IterM m β) → motive { dropping := dropping, inner := inner }) → motive t |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_mul_left_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LT α] [DenselyOrdered α] [MulRightStrictMono α] {a b c : α},
a * b < c → ∃ a' > a, a' * b < c |
CategoryTheory.Limits.CategoricalPullback.comp_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{X Y Z : CategoryTheory.Limits.CategoricalPullback F G} (f : X.Hom Y) (g : Y.Hom Z),
(CategoryTheory.CategoryStruct.comp f g).fst = CategoryTheory.CategoryStruct.comp f.fst g.fst |
TensorProduct.Algebra.module._proof_7 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsScalarTower R B M] (m : M),
0 • m = 0 |
Lean.Compiler.LCNF.instInhabitedFunDecl.default_1 | Lean.Compiler.LCNF.Basic | {a : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.FunDecl a |
CategoryTheory.Bicategory.InducedBicategory.forget._proof_9 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η g).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η.hom g.hom)
(CategoryTheory.eqToHom ⋯)) |
ModuleCat.smul._proof_10 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] (M : ModuleCat R) (r s : R),
AddCommGrpCat.ofHom { toFun := fun m => (r * s) • m, map_zero' := ⋯, map_add' := ⋯ } =
AddCommGrpCat.ofHom { toFun := fun m => r • m, map_zero' := ⋯, map_add' := ⋯ } *
AddCommGrpCat.ofHom { toFun := fun m => s • m, map_zero' := ⋯, map_add' := ⋯ } |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.exists_eq | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} [inst : CategoryTheory.Category.{u, u} I] {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
[inst_1 : ∀ (i : I), CompactSpace ↥(D.obj i)] [AlgebraicGeometry.LocallyOfFiniteType f]
[inst_3 : CategoryTheory.IsCofiltered I] [inst_4 : ∀ {i j : I} (f : i ⟶ j), AlgebraicGeometry.IsAffineHom (D.map f)]
(A : AlgebraicGeometry.ExistsHomHomCompEqCompAux D t f) [∀ (i : I), AlgebraicGeometry.IsAffineHom (A.c.π.app i)]
(j : A.𝒰D.I₀),
∃ k hki',
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ (D.map hki') A.𝒰D).f j)
(CategoryTheory.CategoryStruct.comp (D.map (CategoryTheory.CategoryStruct.comp hki' A.hii')) A.a) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ (D.map hki') A.𝒰D).f j)
(CategoryTheory.CategoryStruct.comp (D.map (CategoryTheory.CategoryStruct.comp hki' A.hii')) A.b) |
SemiRingCat.forget₂AddCommMonPreservesLimitsAux | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
CategoryTheory.Limits.IsLimit
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRingCat.HasLimits.limitCone F)) |
_private.Mathlib.Tactic.Trace.0._aux_Mathlib_Tactic_Trace___elabRules_Lean_Parser_Tactic_trace_1.unsafe_impl_3 | Mathlib.Tactic.Trace | Lean.Expr → Lean.MetaM String |
Finset.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : MulAction α β] (s : Finset β),
Finset.image (fun b => 1 • b) s = s |
ContinuousWithinAt.congr_of_eventuallyEq | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → g =ᶠ[nhdsWithin x s] f → g x = f x → ContinuousWithinAt g s x |
Std.TreeMap.Raw.le_maxKeyD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true |
CategoryTheory.SpectralSequence.Hom.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{t : E.Hom E'} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{u_3, u_1} C'} →
{inst'_1 : CategoryTheory.Abelian C'} →
{κ' : Type u_2} →
{c' : ℤ → ComplexShape κ'} →
{r₀' : ℤ} →
{E'_1 E'' : CategoryTheory.SpectralSequence C' c' r₀'} →
{t' : E'_1.Hom E''} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
κ = κ' →
c ≍ c' →
r₀ = r₀' →
E ≍ E'_1 →
E' ≍ E'' →
t ≍ t' → CategoryTheory.SpectralSequence.Hom.noConfusionType P t t' |
PadicInt.mahlerSeries._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E |
AddOreLocalization.instAddMonoid | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : AddMonoid R] →
{S : AddSubmonoid R} → [inst_1 : AddOreLocalization.AddOreSet S] → AddMonoid (AddOreLocalization S R) |
Std.DTreeMap.Raw.getKey_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} (h' : k ∈ t), t.getKey k h' = k |
Lean.Widget.instAppendInteractiveGoals | Lean.Widget.InteractiveGoal | Append Lean.Widget.InteractiveGoals |
Std.Internal.List.contains_insertList_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) = true ↔
Std.Internal.List.containsKey k l = true ∨ Std.Internal.List.containsKey k toInsert = true |
instInhabitedTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Inhabited (TensorAlgebra R M) |
_private.Mathlib.Data.TypeVec.0.TypeVec.toSubtype'.match_1.eq_1 | Mathlib.Data.TypeVec | ∀
(motive :
(n : ℕ) →
(α : TypeVec.{u_1} n) →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
(x : Fin2 n) → { x_1 // TypeVec.ofRepeat (p x (TypeVec.prod.mk x x_1.1 x_1.2)) } → Sort u_2)
(n : ℕ) (α : TypeVec.{u_1} (n + 1)) (p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) (i : Fin2 n)
(x : { x // TypeVec.ofRepeat (p i.fs (TypeVec.prod.mk i.fs x.1 x.2)) })
(h_1 :
(n : ℕ) →
(α : TypeVec.{u_1} (n + 1)) →
(p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) →
(i : Fin2 n) →
(x : { x // TypeVec.ofRepeat (p i.fs (TypeVec.prod.mk i.fs x.1 x.2)) }) → motive (n + 1) α p i.fs x)
(h_2 :
(n : ℕ) →
(α : TypeVec.{u_1} (n + 1)) →
(p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) →
(x : { x // TypeVec.ofRepeat (p Fin2.fz (TypeVec.prod.mk Fin2.fz x.1 x.2)) }) → motive (n + 1) α p Fin2.fz x),
(match n + 1, α, p, i.fs, x with
| .(n + 1), α, p, i.fs, x => h_1 n α p i x
| .(n + 1), α, p, Fin2.fz, x => h_2 n α p x) =
h_1 n α p i x |
List.eraseIdx_eq_take_drop_succ | Init.Data.List.Erase | ∀ {α : Type u_1} (l : List α) (i : ℕ), l.eraseIdx i = List.take i l ++ List.drop (i + 1) l |
AntitoneOn._to_dual_cast_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
AntitoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a |
_private.Lean.Elab.BuiltinEvalCommand.0.Lean.Elab.Command.mkDeltaInstProj._unsafe_rec | Lean.Elab.BuiltinEvalCommand | Lean.Name → Lean.Name → Lean.Expr → optParam (Option Lean.Expr) none → optParam Bool true → Lean.MetaM Lean.Expr |
UniformContinuousConstSMul.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X],
(∀ (c : M), UniformContinuous fun x => c • x) → UniformContinuousConstSMul M X |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.unsat_of_encounteredBoth._proof_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} (assignment : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(if l.2 = true then Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit l
else Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty) =
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.encounteredBoth →
Std.Tactic.BVDecide.LRAT.Internal.Unsatisfiable (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) assignment |
_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.adaptNat.adaptCnstr.match_1 | Lean.Meta.Tactic.Grind.Order.Internalize | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((rhs' h₂ : Lean.Expr) → motive (rhs', h₂)) → motive __discr |
CategoryTheory.MonoidalOpposite.tensorIso | Mathlib.CategoryTheory.Monoidal.Opposite | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategory.tensor Cᴹᵒᵖ ≅
((CategoryTheory.unmopFunctor C).prod (CategoryTheory.unmopFunctor C)).comp
((CategoryTheory.Prod.swap C C).comp
((CategoryTheory.MonoidalCategory.tensor C).comp (CategoryTheory.mopFunctor C))) |
Lean.mkBRecOn | Lean.Meta.Constructions.BRecOn | Lean.Name → Lean.MetaM Unit |
Lean.Grind.instCommRingUSize._proof_3 | Init.GrindInstances.Ring.UInt | ∀ (i : ℤ) (a : USize), -i • a = -(i • a) |
Lean.Parser.Command.docs_to_verso.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
Submodule.ker_subtype | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), p.subtype.ker = ⊥ |
OrderEmbedding.locallyFiniteOrder | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [LocallyFiniteOrder β] → α ↪o β → LocallyFiniteOrder α |
AddSubsemigroup.mem_inf._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {p p' : AddSubsemigroup M} {x : M}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') |
Finset.notMem_mono | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s |
Quiver.Path.heq_of_cons_eq_cons | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d},
p.cons e = p'.cons e' → p ≍ p' |
Lean.Elab.Command.elabReduce._regBuiltin.Lean.Elab.Command.elabReduce_1 | Lean.Elab.BuiltinCommand | IO Unit |
Aesop.RuleBuilder.cases | Aesop.Builder.Cases | Aesop.RuleBuilder |
UInt32.ofNatLT_bitVecToNat | Init.Data.UInt.Lemmas | ∀ (n : BitVec 32), UInt32.ofNatLT n.toNat ⋯ = { toBitVec := n } |
Subarray.foldr | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → (α → β → β) → β → Subarray α → β |
NNReal.holderConjugate_comm | Mathlib.Data.Real.ConjExponents | ∀ {p q : NNReal}, p.HolderConjugate q ↔ q.HolderConjugate p |
PartENat.withTopEquiv_symm_one | Mathlib.Data.Nat.PartENat | PartENat.withTopEquiv.symm 1 = 1 |
_private.Mathlib.CategoryTheory.Comma.Presheaf.Basic.0.CategoryTheory.OverPresheafAux.MakesOverArrow.map₁._simp_1_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x |
PartialEquiv.IsImage.restr._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {t : Set β}, Set.RightInvOn (↑e.symm) (↑e) (e.target ∩ t) |
_private.Mathlib.Topology.Sequences.0.compactSpace_iff_seqCompactSpace._simp_1_1 | Mathlib.Topology.Sequences | ∀ {X : Type u} [inst : TopologicalSpace X], CompactSpace X = IsCompact Set.univ |
Lean.Elab.Tactic.Do.ProofMode.mRefineCore._unsafe_rec | Lean.Elab.Tactic.Do.ProofMode.Refine | Lean.Elab.Tactic.Do.ProofMode.MGoal →
Lean.Parser.Tactic.MRefinePat →
(Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.TSyntax `Lean.binderIdent → Lean.Elab.Tactic.TacticM Lean.Expr) →
Lean.Elab.Tactic.TacticM Lean.Expr |
Bimod.AssociatorBimod.hom._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[inst_4 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X)]
{R S T U : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T) (L : Bimod T U),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight (P.tensorBimod Q).actRight L.X)
(Bimod.AssociatorBimod.homAux P Q L) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (P.tensorBimod Q).X T.X L.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (P.tensorBimod Q).X L.actLeft))
(Bimod.AssociatorBimod.homAux P Q L) |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right]
{K₁ K₂ :
CategoryTheory.Limits.Fork
(I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left))
(CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))
(I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left))
(CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))}
(f : K₁ ⟶ K₂), (I.multiforkEquivPiFork.inverse.map f).hom = f.hom |
Prod.le_def | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2 |
IsLocalization.Away.sec.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x x_1 : R)
(e_x : x = x_1) [inst_3 : IsLocalization.Away x S] (s s_1 : S),
s = s_1 → IsLocalization.Away.sec x s = IsLocalization.Away.sec x_1 s_1 |
Homotopy.compRight._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i j : ι),
¬c.Rel j i → CategoryTheory.CategoryStruct.comp (h.hom i j) (g.f j) = 0 |
zero_mem_tangentConeAt_iff._simp_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s : Set E} {x : E}, (0 ∈ tangentConeAt 𝕜 s x) = (x ∈ closure s) |
CovariantDerivative.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
[inst_4 : TopologicalSpace M] →
[inst_5 : ChartedSpace H M] →
{F : Type u_5} →
[inst_6 : NormedAddCommGroup F] →
[inst_7 : NormedSpace 𝕜 F] →
{V : M → Type u_6} →
[inst_8 : TopologicalSpace (Bundle.TotalSpace F V)] →
[inst_9 : (x : M) → AddCommGroup (V x)] →
[inst_10 : (x : M) → Module 𝕜 (V x)] →
[inst_11 : (x : M) → TopologicalSpace (V x)] →
[inst_12 : ∀ (x : M), IsTopologicalAddGroup (V x)] →
[inst_13 : ∀ (x : M), ContinuousSMul 𝕜 (V x)] →
[inst_14 : FiberBundle F V] →
CovariantDerivative I F V →
CovariantDerivative I F V → (M → 𝕜) → CovariantDerivative I F V |
Nat.gcd_gcd_self_right_left | Init.Data.Nat.Gcd | ∀ (m n : ℕ), m.gcd (m.gcd n) = m.gcd n |
Std.DHashMap.Internal.Raw₀.Const.get_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : (↑m₁).WF) (h₂ : (↑m₂).WF) (h : (↑m₁).Equiv ↑m₂) {k : α}
(h' : m₁.contains k = true),
Std.DHashMap.Internal.Raw₀.Const.get m₁ k h' = Std.DHashMap.Internal.Raw₀.Const.get m₂ k ⋯ |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, T2Space ↑X.toProfinite.toTop |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.proveEq._sparseCasesOn_4 | Mathlib.Tactic.Ring.Basic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
EuclideanGeometry.Sphere.IsDiameter.mk._flat_ctor | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → midpoint ℝ p₁ p₂ = s.center → s.IsDiameter p₁ p₂ |
FourierInvModule.mk.noConfusion | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
{inst : Add E} →
{inst_1 : Add F} →
{inst_2 : SMul R E} →
{inst_3 : SMul R F} →
{P : Sort u} →
{toFourierTransformInv : FourierTransformInv E F} →
{fourierInv_add :
∀ (f g : E),
FourierTransformInv.fourierInv (f + g) =
FourierTransformInv.fourierInv f + FourierTransformInv.fourierInv g} →
{fourierInv_smul :
∀ (r : R) (f : E),
FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f} →
{toFourierTransformInv' : FourierTransformInv E F} →
{fourierInv_add' :
∀ (f g : E),
FourierTransformInv.fourierInv (f + g) =
FourierTransformInv.fourierInv f + FourierTransformInv.fourierInv g} →
{fourierInv_smul' :
∀ (r : R) (f : E),
FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f} →
{ toFourierTransformInv := toFourierTransformInv, fourierInv_add := fourierInv_add,
fourierInv_smul := fourierInv_smul } =
{ toFourierTransformInv := toFourierTransformInv', fourierInv_add := fourierInv_add',
fourierInv_smul := fourierInv_smul' } →
(toFourierTransformInv ≍ toFourierTransformInv' → P) → P |
hnot_hnot_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢￢￢a = ￢a |
SkewMonoidAlgebra.recOn | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Zero k] →
{motive : SkewMonoidAlgebra k G → Sort u} →
(t : SkewMonoidAlgebra k G) → ((toFinsupp : G →₀ k) → motive { toFinsupp := toFinsupp }) → motive t |
Std.DTreeMap.Internal.Impl.Tree.noConfusion | Std.Data.DTreeMap.Internal.Operations | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{size : ℕ} →
{t : Std.DTreeMap.Internal.Impl.Tree α β size} →
{α' : Type u} →
{β' : α' → Type v} →
{size' : ℕ} →
{t' : Std.DTreeMap.Internal.Impl.Tree α' β' size'} →
α = α' → β ≍ β' → size = size' → t ≍ t' → Std.DTreeMap.Internal.Impl.Tree.noConfusionType P t t' |
Lean.Elab.Deriving.withoutExposeFromCtors | Lean.Elab.Deriving.Util | {α : Type} → Lean.Name → Lean.Elab.Command.CommandElabM α → Lean.Elab.Command.CommandElabM α |
_private.Mathlib.Algebra.Category.HopfAlgCat.Basic.0.HopfAlgCat.mk.sizeOf_spec | Mathlib.Algebra.Category.HopfAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : SizeOf R] (carrier : Type v) [instRing : Ring carrier]
[instHopfAlgebra : HopfAlgebra R carrier],
sizeOf { carrier := carrier, instRing := instRing, instHopfAlgebra := instHopfAlgebra } =
1 + sizeOf carrier + sizeOf instRing + sizeOf instHopfAlgebra |
le_mul_inv_iff_mul_le._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (c ≤ a * b⁻¹) = (c * b ≤ a) |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
FractionalIdeal.extendedHomₐ_injective | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing A K]
[inst_11 : IsFractionRing B L] [inst_12 : Algebra K L] [inst_13 : Algebra A L] [IsScalarTower A B L]
[IsScalarTower A K L] [Algebra.IsIntegral A B] [IsDedekindDomain A] [IsDedekindDomain B],
Function.Injective fun I => (FractionalIdeal.extendedHomₐ L B) I |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
CategoryTheory.Functor C (CategoryTheory.Comon D) → CategoryTheory.Comon (CategoryTheory.Functor C D) |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄.congr_simp | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₃.HasTensor X₄] [inst_4 : X₂.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₃ X₄)]
[inst_5 :
X₁.HasTensor
(CategoryTheory.GradedObject.Monoidal.tensorObj X₂ (CategoryTheory.GradedObject.Monoidal.tensorObj X₃ X₄))]
(i₁ i₂ i₃ i₄ j : I) (h : i₁ + i₂ + i₃ + i₄ = j),
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄ X₁ X₂ X₃ X₄ i₁ i₂ i₃ i₄ j h =
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄ X₁ X₂ X₃ X₄ i₁ i₂ i₃ i₄ j h |
vadd_left_cancel_iff._simp_1 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = g +ᵥ y) = (x = y) |
FinPartOrd.instCoeSortType | Mathlib.Order.Category.FinPartOrd | CoeSort FinPartOrd (Type u_1) |
List.fixedLengthDigits.congr_simp | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b b_1 : ℕ} (e_b : b = b_1) (hb : 1 < b) (l l_1 : ℕ),
l = l_1 → List.fixedLengthDigits hb l = List.fixedLengthDigits ⋯ l_1 |
CategoryTheory.Bicategory.postcomposingCat._proof_4 | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y Z : b ⟶ c} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.toCatHom₂
((CategoryTheory.Bicategory.postcomposing a b c).map (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCatHom₂ ((CategoryTheory.Bicategory.postcomposing a b c).map f))
(CategoryTheory.NatTrans.toCatHom₂ ((CategoryTheory.Bicategory.postcomposing a b c).map g)) |
Lean.Elab.Tactic.Conv.evalLiftLets | Lean.Elab.Tactic.Conv.Lets | Lean.Elab.Tactic.Tactic |
Pi.monotoneCurry | Mathlib.Control.LawfulFix | (α : Type u_1) →
(β : α → Type u_2) →
(γ : (a : α) → β a → Type u_3) →
[inst : (x : α) → (y : β x) → Preorder (γ x y)] →
((x : (a : α) × β a) → γ x.fst x.snd) →o (a : α) → (b : β a) → γ a b |
Commute.natCast_mul_self | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : Semiring α] (a : α) (n : ℕ), Commute (↑n * a) a |
MeasureTheory.Measure.regular_of_isAddLeftInvariant | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] [SecondCountableTopology G] {μ : MeasureTheory.Measure G}
[MeasureTheory.SigmaFinite μ] [μ.IsAddLeftInvariant] {K : Set G},
IsCompact K → (interior K).Nonempty → μ K ≠ ⊤ → μ.Regular |
ULift.inv.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : Inv α], ULift.inv = { inv := fun f => { down := f.down⁻¹ } } |
_private.Mathlib.Analysis.Calculus.DifferentialForm.VectorField.0.extDeriv_apply_vectorField_of_pairwise_commute._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f Set.univ x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.