name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Function.Surjective.smulCommClass | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} {β : Type u_6} [inst : SMul M α] [inst_1 : SMul N α] [inst_2 : SMul M β]
[inst_3 : SMul N β] [SMulCommClass M N α] {f : α → β},
Function.Surjective f →
(∀ (c : M) (x : α), f (c • x) = c • f x) → (∀ (c : N) (x : α), f (c • x) = c • f x) → SMulCommClass M N β |
CompHausLike.LocallyConstant.sigmaIso._proof_3 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
{Q : CompHausLike P} {Z : Type (max u_1 u_2)} (r : LocallyConstant (↑Q.toTop) Z),
CompactSpace ((i : Function.Fiber ⇑r) × ↑(CompHausLike.LocallyConstant.fiber r i).toTop) |
extChartAt_self_apply | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ (𝕜 : Type u_1) {E : Type u_2} {H : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {x y : H},
↑(extChartAt I x) y = ↑I y |
CategoryTheory.InjectiveResolution.definition._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[CategoryTheory.EnoughInjectives C] → (Z : C) → CategoryTheory.InjectiveResolution Z |
Lean.Elab.Info.ofChoiceInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 14 → ((i : Lean.Elab.ChoiceInfo) → motive (Lean.Elab.Info.ofChoiceInfo i)) → motive t |
one_half_le_sum_primes_ge_one_div | Mathlib.NumberTheory.SumPrimeReciprocals | ∀ (k : ℕ), 1 / 2 ≤ ∑ p ∈ (4 ^ (k.primesBelow.card + 1)).succ.primesBelow \ k.primesBelow, 1 / ↑p |
List.isEmpty_eq_false_iff._simp_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = false) = (l ≠ []) |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ico._simp_1_2 | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} {i j : Fin n}, (i.rev < j) = (j.rev < i) |
Stream'.Seq.update._proof_2 | Mathlib.Data.Seq.Defs | ∀ {α : Type u_1} (s : Stream'.Seq α) (n : ℕ) (f : α → α), Stream'.IsSeq (Function.update (↑s) n (Option.map f (↑s n))) |
Complex.continuousWithinAt_log_of_re_neg_of_im_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {z : ℂ}, z.re < 0 → z.im = 0 → ContinuousWithinAt Complex.log {z | 0 ≤ z.im} z |
FreeGroup.Red.Step.cons_not | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {x : α} {b : Bool}, FreeGroup.Red.Step ((x, b) :: (x, !b) :: L) L |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.unreduced_edges_subset._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
Complementeds.disjoint_coe._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : BoundedOrder α] {a b : Complementeds α},
Disjoint ↑a ↑b = Disjoint a b |
_private.Mathlib.Order.CompleteLattice.PiLex.0.Pi.Colex.instInfSetColexForall._proof_1 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} [inst : LinearOrder ι] [WellFoundedGT ι], IsWellFounded ιᵒᵈ fun x1 x2 => x1 < x2 |
StrictConcaveOn.lt_map_sum | Mathlib.Analysis.Convex.Jensen | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} {ι : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜]
[IsStrictOrderedRing 𝕜] [inst_3 : AddCommGroup E] [inst_4 : AddCommGroup β] [inst_5 : PartialOrder β]
[IsOrderedAddMonoid β] [inst_7 : Module 𝕜 E] [inst_8 : Module 𝕜 β] [IsStrictOrderedModule 𝕜 β] {s : Set E} {f : E → β}
{t : Finset ι} {w : ι → 𝕜} {p : ι → E},
StrictConcaveOn 𝕜 s f →
(∀ i ∈ t, 0 < w i) →
∑ i ∈ t, w i = 1 →
(∀ i ∈ t, p i ∈ s) → (∃ j ∈ t, ∃ k ∈ t, p j ≠ p k) → ∑ i ∈ t, w i • f (p i) < f (∑ i ∈ t, w i • p i) |
Lean.PrettyPrinter.Formatter.pushToken | Lean.PrettyPrinter.Formatter | Lean.SourceInfo → String → Bool → Lean.PrettyPrinter.FormatterM Unit |
Lean.Meta.instReduceEvalLiteral_qq | Qq.ForLean.ReduceEval | Lean.Meta.ReduceEval Lean.Literal |
BitVec.getLsb'_ofFnBE | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : Fin n), (BitVec.ofFnBE f).getLsb i = f i.rev |
Set.Icc.mul_le_right | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {x y : ↑(Set.Icc 0 1)},
x * y ≤ y |
_private.Init.Omega.IntList.0.List.getElem?_map.match_1_1 | Init.Omega.IntList | ∀ {α : Type u_1} (motive : List α → ℕ → Prop) (x : List α) (x_1 : ℕ),
(∀ (x : ℕ), motive [] x) →
(∀ (head : α) (tail : List α), motive (head :: tail) 0) →
(∀ (head : α) (l : List α) (i : ℕ), motive (head :: l) i.succ) → motive x x_1 |
StarRingEquiv.trans | Mathlib.Algebra.Star.StarRingHom | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
[inst : Add A] →
[inst_1 : Add B] →
[inst_2 : Mul A] →
[inst_3 : Mul B] →
[inst_4 : Star A] →
[inst_5 : Star B] →
[inst_6 : Add C] → [inst_7 : Mul C] → [inst_8 : Star C] → (A ≃⋆+* B) → (B ≃⋆+* C) → A ≃⋆+* C |
_private.Mathlib.LinearAlgebra.BilinearForm.Orthogonal.0.LinearMap.BilinForm.ker_restrict_eq_of_codisjoint._simp_1_2 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) |
IsPRadical.injective_comp | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} (M : Type u_3) [inst : CommRing K] [inst_1 : CommRing L] [inst_2 : CommRing M]
(i : K →+* L) (p : ℕ) [ExpChar M p] [IsPRadical i p] [IsReduced M], Function.Injective fun f => f.comp i |
Algebra.FinitePresentation.mvPolynomial_of_finitePresentation | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type w₁} {A : Type w₂} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[Algebra.FinitePresentation R A] (ι : Type v) [Finite ι], Algebra.FinitePresentation R (MvPolynomial ι A) |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.loop.match_1 | Lean.Meta.Tactic.Grind.Action | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n |
isAddRegular_unop | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Add R] {a : Rᵃᵒᵖ}, IsAddRegular (AddOpposite.unop a) ↔ IsAddRegular a |
Lean.Meta.CheckAssignment.Context.rec | Lean.Meta.ExprDefEq | {motive : Lean.Meta.CheckAssignment.Context → Sort u} →
((mvarId : Lean.MVarId) →
(mvarDecl : Lean.MetavarDecl) →
(fvars : Array Lean.Expr) →
(hasCtxLocals : Bool) →
(rhs : Lean.Expr) →
motive
{ mvarId := mvarId, mvarDecl := mvarDecl, fvars := fvars, hasCtxLocals := hasCtxLocals, rhs := rhs }) →
(t : Lean.Meta.CheckAssignment.Context) → motive t |
Polynomial.add_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {q : Polynomial R} (p₁ p₂ : Polynomial R), (p₁ + p₂) %ₘ q = p₁ %ₘ q + p₂ %ₘ q |
SSet.Subcomplex.PairingCore.pairing._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (h : A.PairingCore), h.I ∩ h.II = ∅ |
_private.Init.Data.Nat.Gcd.0.Nat.gcd_pos_iff._simp_1_2 | Init.Data.Nat.Gcd | ∀ {p q : Prop} [d₁ : Decidable p] [d₂ : Decidable q], (¬(p ∧ q)) = (¬p ∨ ¬q) |
Function.OfArity.curry_two_eq_curry | Mathlib.Data.Fin.Tuple.Curry | ∀ {α β : Type u} (f : (Fin 2 → α) → β), Function.OfArity.curry f = Function.curry (f ∘ ⇑(finTwoArrowEquiv α).symm) |
Turing.TM2.stepAux.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K] (x : σ)
(x_1 : (k : K) → List (Γ k)) (k : K) (f : σ → Γ k) (q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2.stepAux (Turing.TM2.Stmt.push k f q) x x_1 = Turing.TM2.stepAux q x (Function.update x_1 k (f x :: x_1 k)) |
_private.Lean.Compiler.LCNF.Simp.DiscrM.0.Lean.Compiler.LCNF.Simp.withDiscrCtorImp.updateCtx.match_1 | Lean.Compiler.LCNF.Simp.DiscrM | (motive : Option (List Lean.Level × Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) → Sort u_1) →
(__do_lift : Option (List Lean.Level × Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure))) →
((us : List Lean.Level) →
(params : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) → motive (some (us, params))) →
((x : Option (List Lean.Level × Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure))) → motive x) →
motive __do_lift |
addMonoidHomOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Monoid | ∀ {M₁ : Type u_6} {M₂ : Type u_7} [inst : TopologicalSpace M₂] [inst_1 : T2Space M₂] [inst_2 : AddZeroClass M₁]
[inst_3 : AddZeroClass M₂] [inst_4 : ContinuousAdd M₂] {F : Type u_8} [inst_5 : FunLike F M₁ M₂]
[inst_6 : AddMonoidHomClass F M₁ M₂] (f : M₁ → M₂) (hf : f ∈ closure (Set.range fun f x => f x)),
⇑(addMonoidHomOfMemClosureRangeCoe f hf) = f |
ExpChar.zero | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R], ExpChar R 1 |
UInt8.toUInt16_div | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a / b).toUInt16 = a.toUInt16 / b.toUInt16 |
Rat.instSemilatticeInf | Mathlib.Algebra.Order.Ring.Unbundled.Rat | SemilatticeInf ℚ |
CategoryTheory.Subfunctor.range_eq_top | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F)
[CategoryTheory.Epi p], CategoryTheory.Subfunctor.range p = ⊤ |
Associates.instCommMonoidWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] (a : M), 0 * Associates.mk a = 0 |
ISize.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : ISize), ISize.minValue.toInt ≤ x.toInt |
ContinuousLinearMap.isPositive_self_comp_adjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : CompleteSpace E] [inst_6 : CompleteSpace F] (S : E →L[𝕜] F),
(S.comp (ContinuousLinearMap.adjoint S)).IsPositive |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_not_mem_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : Inhabited α],
t.WF →
∀ {l : List α} {k k' : α},
compare k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬compare a b = Ordering.eq) l →
k ∈ l → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l)).getKey! k' = k |
Aesop.Frontend.AttrConfig.noConfusionType | Aesop.Frontend.Attribute | Sort u → Aesop.Frontend.AttrConfig → Aesop.Frontend.AttrConfig → Sort u |
Std.TreeSet.le_max!_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
k ∈ t → (cmp k t.max!).isLE = true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_right_p | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.homologyDataIdId._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.homologyDataIdId._auto_3),
(X.homologyDataIdId f n₀ n₁ n₂ hn₁ hn₂).right.p =
CategoryTheory.CategoryStruct.id ((X.H n₁).obj (CategoryTheory.ComposableArrows.mk₁ f)) |
Std.ExtHashSet.ext_mem | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] {m₁ m₂ : Std.ExtHashSet α},
(∀ (k : α), k ∈ m₁ ↔ k ∈ m₂) → m₁ = m₂ |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.EMatchTheoremKind.toAttributeCore.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u_1) →
(kind : Lean.Meta.Grind.EMatchTheoremKind) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs true)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs true)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqBoth false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.eqBoth true)) →
(Unit → motive Lean.Meta.Grind.EMatchTheoremKind.eqBwd) →
(Unit → motive Lean.Meta.Grind.EMatchTheoremKind.fwd) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.bwd false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.bwd true)) →
(Unit → motive Lean.Meta.Grind.EMatchTheoremKind.leftRight) →
(Unit → motive Lean.Meta.Grind.EMatchTheoremKind.rightLeft) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.default false)) →
(Unit → motive (Lean.Meta.Grind.EMatchTheoremKind.default true)) →
(Unit → motive Lean.Meta.Grind.EMatchTheoremKind.user) → motive kind |
Sigma.forall | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
(∀ (x : (a : α) × β a), p x) ↔ ∀ (a : α) (b : β a), p ⟨a, b⟩ |
Lean._aux_Init_Meta___macroRules_Lean_Parser_Syntax_addPrio_1 | Init.Meta | Lean.Macro |
SchwartzMap.instIsUniformAddGroup | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F], IsUniformAddGroup (SchwartzMap E F) |
ChainComplex.truncateAugment._proof_3 | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : ChainComplex V ℕ) {X : V} (f : C.X 0 ⟶ X) (w : CategoryTheory.CategoryStruct.comp (C.d 1 0) f = 0) (i j : ℕ),
(ComplexShape.down ℕ).Rel i j →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (C.X i))
((ChainComplex.truncate.obj (C.augment f w)).d i j) =
CategoryTheory.CategoryStruct.comp (C.d i j) (CategoryTheory.CategoryStruct.id (C.X j)) |
Lean.Elab.Tactic.Do.ProofMode.ensureMGoal | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Elab.Tactic.TacticM (Lean.MVarId × Lean.Elab.Tactic.Do.ProofMode.MGoal) |
NumberField.CMExtension.algebraMap_equivMaximalRealSubfield_symm_apply | Mathlib.NumberTheory.NumberField.CMField | ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : NumberField.IsTotallyReal F] [inst_2 : Field K]
[inst_3 : CharZero K] [inst_4 : Algebra.IsIntegral ℚ K] [inst_5 : NumberField.IsTotallyComplex K]
[inst_6 : Algebra F K] [inst_7 : Algebra.IsQuadraticExtension F K] (x : ↥(NumberField.maximalRealSubfield K)),
(algebraMap F K) ((NumberField.CMExtension.equivMaximalRealSubfield F K).symm x) =
(algebraMap (↥(NumberField.maximalRealSubfield K)) K) x |
IsLocalization.Away.awayToAwayRight_eq | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] (x : R) [inst_4 : IsLocalization.Away x S] (y : R) [inst_5 : Algebra R P]
[inst_6 : IsLocalization.Away (x * y) P] (a : R),
(IsLocalization.Away.awayToAwayRight x y) ((algebraMap R S) a) = (algebraMap R P) a |
Int.mul_le_mul_left._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, 0 < a → (a * b ≤ a * c) = (b ≤ c) |
EReal.Tendsto.const_mul | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {f : Filter α} {m : α → EReal} {a b : EReal},
Filter.Tendsto m f (nhds b) → a ≠ ⊥ ∨ b ≠ 0 → a ≠ ⊤ ∨ b ≠ 0 → Filter.Tendsto (fun b => a * m b) f (nhds (a * b)) |
Lean.Elab.Command.AssertExists._sizeOf_1 | Lean.Elab.AssertExists | Lean.Elab.Command.AssertExists → ℕ |
CategoryTheory.Discrete.monoidalFunctorMonoidal._proof_10 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] (F : M →* N) (X : CategoryTheory.Discrete M),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor ((CategoryTheory.Discrete.monoidalFunctor F).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Discrete.monoidalFunctor F).obj X)
(CategoryTheory.Discrete.eqToIso ⋯).hom)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Discrete.eqToIso ⋯).hom
((CategoryTheory.Discrete.monoidalFunctor F).map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)) |
_private.Mathlib.Topology.Bornology.BoundedOperation.0.isBounded_pow._simp_1_2 | Mathlib.Topology.Bornology.BoundedOperation | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
Multiset.le_union_left | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ≤ s ∪ t |
SzemerediRegularity.coe_stepBound | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | ∀ {α : Type u_1} [inst : Semiring α] (n : ℕ), ↑(SzemerediRegularity.stepBound n) = ↑n * 4 ^ n |
HomologicalComplex.Hom.ext_iff | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} {inst : CategoryTheory.Category.{v, u} V}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} {c : ComplexShape ι} {A B : HomologicalComplex V c}
{x y : A.Hom B}, x = y ↔ x.f = y.f |
BooleanSubalgebra.sSup_mem | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : CompleteBooleanAlgebra α] {L : BooleanSubalgebra α} {s : Set α}, s.Finite → s ⊆ ↑L → sSup s ∈ L |
Concept.strictAnti_intent | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop}, StrictAnti Concept.intent |
AddSubgroup.inf_addSubgroupOf_left | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] (H K : AddSubgroup G), (K ⊓ H).addSubgroupOf K = H.addSubgroupOf K |
_private.Init.Data.Int.LemmasAux.0.Int.toNat_sub_of_le._proof_1_1 | Init.Data.Int.LemmasAux | ∀ {a b : ℤ}, b ≤ a → ¬↑(a - b).toNat = a - b → False |
ULift.nonUnitalNonAssocSemiring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : NonUnitalNonAssocSemiring R] (a : ULift.{u_1, u_2} R), 0 * a = 0 |
Polynomial.content.eq_1 | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] (p : Polynomial R),
p.content = p.support.gcd p.coeff |
CochainComplex.singleFunctors._proof_8 | Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (n m a a' a'' : ℤ) (ha' : n + a = a') (ha'' : m + a' = a''),
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯ =
(HomologicalComplex.single C (ComplexShape.up ℤ) a'').isoWhiskerLeft
(CategoryTheory.shiftFunctorAdd (CochainComplex C ℤ) m n) ≪≫
((HomologicalComplex.single C (ComplexShape.up ℤ) a'').associator
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) m)
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) n)).symm ≪≫
CategoryTheory.Functor.isoWhiskerRight
(CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯)
(CategoryTheory.shiftFunctor (CochainComplex C ℤ) n) ≪≫
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯ |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_3, u_5} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) [inst_2 : G.LocallyCoverDense K] [inst_3 : G.IsLocallyFull K]
[inst_4 : G.IsLocallyFaithful K] [G.IsCoverDense K], G.IsContinuous (G.inducedTopology K) K |
Semiquot.IsPure | Mathlib.Data.Semiquot | {α : Type u_1} → Semiquot α → Prop |
CategoryTheory.Limits.CatCospanTransform.category | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{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} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] →
[inst_4 : CategoryTheory.Category.{v₅, u₅} B'] →
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] →
{F' : CategoryTheory.Functor A' B'} →
{G' : CategoryTheory.Functor C' B'} →
CategoryTheory.Category.{max (max (max (max (max u₃ u₂) u₁) v₆) v₅) v₄,
max
(max
(max
(max (max (max (max (max (max (max (max u₆ u₅) u₄) u₃) u₂) u₁) v₆) v₅) v₄)
v₃)
v₂)
v₁}
(CategoryTheory.Limits.CatCospanTransform F G F' G') |
Vector.map_zip_eq_zipWith | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} {f : α × β → γ} {as : Vector α n} {bs : Vector β n},
Vector.map f (as.zip bs) = Vector.zipWith (Function.curry f) as bs |
Lean.Grind.AC.Seq.startsWithVar_k_cons | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var) (s : Lean.Grind.AC.Seq), (Lean.Grind.AC.Seq.cons y s).startsWithVar_k x = (x == y) |
LieAlgebra.LoopAlgebra.residuePairing._proof_3 | Mathlib.Algebra.Lie.Loop | ∀ (R : Type u_1) (A : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup A] [inst_4 : DistribSMul A R] (Φ : LinearMap.BilinForm R L)
(f x y : LieAlgebra.loopAlgebra R A L),
(((LieAlgebra.LoopAlgebra.toFinsupp R A L) (x + y)).sum fun a v =>
a • (Φ (((LieAlgebra.LoopAlgebra.toFinsupp R A L) f) (-a))) v) =
(((LieAlgebra.LoopAlgebra.toFinsupp R A L) x).sum fun a v =>
a • (Φ (((LieAlgebra.LoopAlgebra.toFinsupp R A L) f) (-a))) v) +
((LieAlgebra.LoopAlgebra.toFinsupp R A L) y).sum fun a v =>
a • (Φ (((LieAlgebra.LoopAlgebra.toFinsupp R A L) f) (-a))) v |
Lean.Omega.Int.add_le_zero_iff_le_neg | Init.Omega.Int | ∀ {a b : ℤ}, a + b ≤ 0 ↔ a ≤ -b |
_private.Mathlib.Analysis.Complex.Periodic.0.Function.Periodic.qParam_ne_zero._simp_1_2 | Mathlib.Analysis.Complex.Periodic | ∀ (x : ℂ), (Complex.exp x = 0) = False |
ENat.epow_zero | Mathlib.Data.ENat.Pow | ∀ {x : ℕ∞}, x ^ 0 = 1 |
Filter.indicator_const_eventuallyEq | Mathlib.Order.Filter.IndicatorFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero β] {l : Filter α} {c : β},
c ≠ 0 → ∀ {s t : Set α}, ((s.indicator fun x => c) =ᶠ[l] t.indicator fun x => c) ↔ s =ᶠ[l] t |
Cardinal.mul_natCast_lt_mul_natCast._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n < b * ↑n) = (a < b) |
ContinuousMapZero.instCanLift | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R], CanLift C(X, R) (ContinuousMapZero X R) toContinuousMap fun f => f 0 = 0 |
List.drop.eq_2 | Init.Data.Array.GetLit | ∀ {α : Type u} (n : ℕ), List.drop n.succ [] = [] |
Int32.or_comm | Init.Data.SInt.Bitwise | ∀ (a b : Int32), a ||| b = b ||| a |
Flow.isSemiconjugacy_id_iff_eq | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} [inst : AddMonoid τ] [inst_1 : TopologicalSpace τ] [inst_2 : ContinuousAdd τ] {α : Type u_2}
[inst_3 : TopologicalSpace α] (ϕ ψ : Flow τ α), Flow.IsSemiconjugacy id ϕ ψ ↔ ϕ = ψ |
AlgebraicGeometry.Scheme.isLocallyArtinianScheme_Spec | Mathlib.AlgebraicGeometry.Artinian | ∀ {R : CommRingCat}, AlgebraicGeometry.IsLocallyArtinian (AlgebraicGeometry.Spec R) ↔ IsArtinianRing ↑R |
Projectivization.lift_mk | Mathlib.LinearAlgebra.Projectivization.Basic | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {α : Type u_3}
(f : { v // v ≠ 0 } → α) (hf : ∀ (a b : { v // v ≠ 0 }) (t : K), ↑a = t • ↑b → f a = f b) (v : V) (hv : v ≠ 0),
Projectivization.lift f hf (Projectivization.mk K v hv) = f ⟨v, hv⟩ |
AlgCat.instMonoidalCategory | Mathlib.Algebra.Category.AlgCat.Monoidal | {R : Type u} → [inst : CommRing R] → CategoryTheory.MonoidalCategory (AlgCat R) |
Std.Rxo.Iterator.mk.noConfusion | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
{P : Sort u_1} →
{next : Option α} →
{upperBound : α} →
{next' : Option α} →
{upperBound' : α} →
{ next := next, upperBound := upperBound } = { next := next', upperBound := upperBound' } →
(next ≍ next' → upperBound ≍ upperBound' → P) → P |
SimpleGraph.Walk.nil_nil._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | ∀ {V : Type u} {G : SimpleGraph V} {u : V}, SimpleGraph.Walk.nil.Nil = True |
CategoryTheory.Adjunction.corepresentableBy._proof_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (X : C) {Y Y' : D} (g : Y ⟶ Y') (f : F.obj X ⟶ Y),
(adj.homEquiv X Y') (CategoryTheory.CategoryStruct.comp f g) =
(G.comp (CategoryTheory.coyoneda.obj (Opposite.op X))).map g ((adj.homEquiv X Y) f) |
RingHom.instMonoid._proof_1 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_1} {x : NonAssocSemiring α} (n : ℕ) (f : α →+* α), (⇑f)^[n] = ⇑(npowRec n f) |
Nat.shiftLeft'.eq_1 | Mathlib.Data.Nat.Bits | ∀ (b : Bool) (m : ℕ), Nat.shiftLeft' b m 0 = m |
QuadraticForm.isometryEquivWeightedSumSquares._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_1} [inst : Field K], SMulCommClass K K K |
CategoryTheory.GrothendieckTopology.Point.skyscraperSheafFunctor | Mathlib.CategoryTheory.Sites.Point.Skyscraper | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
J.Point →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[CategoryTheory.Limits.HasProducts A] → CategoryTheory.Functor A (CategoryTheory.Sheaf J A) |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.recOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref) → motive { w := w, vec := vec, cin := cin }) →
motive t |
CategoryTheory.ObjectProperty.IsSeparating.isDetecting | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.ObjectProperty C}
[CategoryTheory.Balanced C], P.IsSeparating → P.IsDetecting |
initFn._@.Mathlib.Tactic.TacticAnalysis.Declarations.66427035._hygCtx._hyg.4 | Mathlib.Tactic.TacticAnalysis.Declarations | IO (Lean.Option Bool) |
_private.Mathlib.LinearAlgebra.SesquilinearForm.Basic.0.LinearMap.isOrtho_flip._simp_1_1 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_5} {M₁ : Type u_6} {M₂ : Type u_7} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : AddCommMonoid M₁] [inst_3 : Module R₁ M₁] [inst_4 : CommSemiring R₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₂ M₂] [inst_7 : AddCommMonoid M] [inst_8 : Module R M] {I₁ : R₁ →+* R}
{I₂ : R₂ →+* R} {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} {x : M₁} {y : M₂}, B.IsOrtho x y = ((B x) y = 0) |
_private.Lean.Parser.Extension.0.Lean.Parser.addParserCategoryCore | Lean.Parser.Extension | Lean.Parser.ParserCategories → Lean.Name → Lean.Parser.ParserCategory → Except String Lean.Parser.ParserCategories |
Submodule.topEquiv | Mathlib.Algebra.Module.Submodule.Lattice | {R : Type u_1} → {M : Type u_3} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → ↥⊤ ≃ₗ[R] M |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.