name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.entryAtIdx?_eq_getElem?._simp_1_3 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b : ℕ}, (compare a b = Ordering.eq) = (a = b) |
ArchimedeanOrder.of | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → M ≃ ArchimedeanOrder M |
WriterT.uliftable' | Mathlib.Control.ULiftable | {w : Type u_3} →
{w' : Type u_4} →
{m : Type u_3 → Type u_5} →
{m' : Type u_4 → Type u_6} → [ULiftable m m'] → w ≃ w' → ULiftable (WriterT w m) (WriterT w' m') |
USize.ofBitVec.sizeOf_spec | Init.SizeOf | ∀ (toBitVec : BitVec System.Platform.numBits), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec |
CommRingCat.instCategory._proof_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y : CommRingCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f |
mul_eq_zero_iff_right | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, b ≠ 0 → (a * b = 0 ↔ a = 0) |
WithLp.instProdPseudoMetricSpace | Mathlib.Analysis.Normed.Lp.ProdLp | (p : ENNReal) →
(α : Type u_2) →
(β : Type u_3) →
[hp : Fact (1 ≤ p)] → [PseudoMetricSpace α] → [PseudoMetricSpace β] → PseudoMetricSpace (WithLp p (α × β)) |
CategoryTheory.Limits.LimitPresentation.changeDiag | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(P : CategoryTheory.Limits.LimitPresentation J X) →
{F : CategoryTheory.Functor J C} → (F ≅ P.diag) → CategoryTheory.Limits.LimitPresentation J X |
Stream'.Seq.cons_not_terminatedAt_zero._simp_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {x : α} {s : Stream'.Seq α}, (Stream'.Seq.cons x s).TerminatedAt 0 = False |
Denumerable | Mathlib.Logic.Denumerable | Type u_3 → Type u_3 |
BitVec.toInt_sshiftRight' | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x.sshiftRight' y).toInt = x.toInt >>> y.toNat |
TopologicalSpace.Opens.map_id_obj | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(lα : Q(LT «$α»)) →
{a b : Q(«$α»)} →
Mathlib.Meta.NormNum.Result a →
Mathlib.Meta.NormNum.Result b →
have e := q(«$a» < «$b»);
Lean.MetaM (Mathlib.Meta.NormNum.Result e) |
Std.Internal.IO.Async.Signal.sigttou.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 14 → motive Std.Internal.IO.Async.Signal.sigttou → motive t |
normSeminorm | Mathlib.Analysis.Seminorm | (𝕜 : Type u_3) →
(E : Type u_7) →
[inst : NormedField 𝕜] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Seminorm 𝕜 E |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 |
CategoryTheory.ShortComplex.Splitting.map | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{S : CategoryTheory.ShortComplex C} →
S.Splitting → (F : CategoryTheory.Functor C D) → [inst_4 : F.Additive] → (S.map F).Splitting |
Lean.PersistentHashMap.Node.brecOn_3 | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
{motive_2 : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_3 : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_4 : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_1} →
(t : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
((t : Lean.PersistentHashMap.Node α β) → t.below → motive_1 t) →
((t : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
Lean.PersistentHashMap.Node.below_1 t → motive_2 t) →
((t : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
Lean.PersistentHashMap.Node.below_2 t → motive_3 t) →
((t : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
Lean.PersistentHashMap.Node.below_3 t → motive_4 t) →
motive_4 t |
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1)
(hT : MeasureTheory.DominatedFinMeasAdditive μ T C),
MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT = MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ ⋯ |
Subgroup.prod_eq_bot_iff._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N},
(H.prod K = ⊥) = (H = ⊥ ∧ K = ⊥) |
specializingMap_iff_isClosed_image_closure_singleton | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f → (SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})) |
Module.Basis.traceDual_traceDual | Mathlib.RingTheory.Trace.Basic | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ι : Type w}
[inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ι] [inst_6 : DecidableEq ι]
(b : Module.Basis ι K L), b.traceDual.traceDual = b |
Lean.Meta.Match.Pattern.val.sizeOf_spec | Lean.Meta.Match.Basic | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e |
MeasureTheory.MemLp.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.MemLp (fun x => (f x).fst) p μ ∧ MeasureTheory.MemLp (fun x => (f x).snd) p μ →
MeasureTheory.MemLp f p μ |
Delone.DeloneSet.mapIsometry_refl | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X),
(Delone.DeloneSet.mapIsometry (IsometryEquiv.refl X)) D = D |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.inj | Lean.Server.FileWorker.WidgetRequests | ∀ {query : String} {ms : Array String.Pos.Raw} {p : String.Pos.Raw} {anyHighlight : Bool} {query_1 : String}
{ms_1 : Array String.Pos.Raw} {p_1 : String.Pos.Raw} {anyHighlight_1 : Bool},
{ query := query, ms := ms, p := p, anyHighlight := anyHighlight } =
{ query := query_1, ms := ms_1, p := p_1, anyHighlight := anyHighlight_1 } →
query = query_1 ∧ ms = ms_1 ∧ p = p_1 ∧ anyHighlight = anyHighlight_1 |
Set.inv_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a ∈ Set.center M → a⁻¹ ∈ Set.center M |
MeasureTheory.Measure.pi.isOpenPosMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi μ).IsOpenPosMeasure |
LocallyConstant.indicator_of_notMem | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a ∉ U → (f.indicator hU) a = 0 |
Lean.Grind.instCommRingUSize._proof_5 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : USize), ↑↑n * a = ↑n * a |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x.toInt < 0 → 0 ≤ x.toInt → False |
Lean.Compiler.LCNF.specExtension | Lean.Compiler.LCNF.SpecInfo | Lean.SimplePersistentEnvExtension Lean.Compiler.LCNF.SpecEntry Lean.Compiler.LCNF.SpecState |
Bipointed.swapEquiv_functor_map_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a |
Batteries.RBNode.foldr.match_1 | Batteries.Data.RBMap.Basic | {α : Type u_1} →
{σ : Sort u_3} →
(motive : Batteries.RBNode α → σ → Sort u_2) →
(x : Batteries.RBNode α) →
(x_1 : σ) →
((b : σ) → motive Batteries.RBNode.nil b) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) →
(v : α) → (r : Batteries.RBNode α) → (b : σ) → motive (Batteries.RBNode.node c l v r) b) →
motive x x_1 |
Nat.greatestFib.eq_1 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k ≤ n) (n + 1) |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.getFieldDefaultValue? | Lean.Elab.Structure | Lean.Name → Array Lean.Expr → Lean.Name → Lean.Elab.Command.Structure.StructElabM✝ (Option Lean.Expr) |
surjOn_Icc_of_monotone_surjective | Mathlib.Order.Interval.Set.SurjOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] {f : α → β},
Monotone f → Function.Surjective f → ∀ {a b : α}, a ≤ b → Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b)) |
MeasureTheory.JordanDecomposition.zero_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.JordanDecomposition.posPart 0 = 0 |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ), i < j → j < k → k < tail.length + 1 → i < tail.length |
MapClusterPt.prodMap | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {α : Type u_5} {β : Type u_6}
{f : α → X} {g : β → Y} {la : Filter α} {lb : Filter β} {x : X} {y : Y},
MapClusterPt x la f → MapClusterPt y lb g → MapClusterPt (x, y) (la ×ˢ lb) (Prod.map f g) |
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), (0#w).ult a = !a == 0#w |
GroupExtension.Splitting.semidirectProductMulEquiv | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → (s : S.Splitting) → N ⋊[s.conjAct] G ≃* E |
CompTriple.IsId.rec | Mathlib.Logic.Function.CompTypeclasses | {M : Type u_1} →
{σ : M → M} →
{motive : CompTriple.IsId σ → Sort u} → ((eq_id : σ = id) → motive ⋯) → (t : CompTriple.IsId σ) → motive t |
_private.Lean.Data.Array.0.Array.mask.match_1 | Lean.Data.Array | {α : Type u_1} →
(motive : Option (α × Subarray α) → Sort u_2) →
(x : Option (α × Subarray α)) →
(Unit → motive none) → ((x : α) → (s' : Subarray α) → motive (some (x, s'))) → motive x |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : ¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hcurr fun hcurr s => w - curr)
⟨curr + 1, ⟨⋯, s.push (input.get (curr - distance) ⋯)⟩⟩ ⟨curr, ⟨hcurr, s⟩⟩ |
neg_add_cancel_comm_assoc | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b |
Set.countable_setOf_finite_subset | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Countable → {t | t.Finite ∧ t ⊆ s}.Countable |
CategoryTheory.Pi.μ_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I) (X Y : (i : I) → C i),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj (X i) (Y i)) |
IntervalIntegrable.mono_set | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b c d : ℝ}
{μ : MeasureTheory.Measure ℝ} [TopologicalSpace.PseudoMetrizableSpace ε],
IntervalIntegrable f μ a b → Set.uIcc c d ⊆ Set.uIcc a b → IntervalIntegrable f μ c d |
Set.restrict_ite_compl | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [inst : (x : α) → Decidable (x ∈ s)],
(sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] (L : CategoryTheory.Functor C₂ D) [inst_3 : L.IsLocalization W₂]
{X₂ : C₂} {X₃ : D} (y : L.obj X₂ ⟶ X₃) {R R' : Φ.RightResolution X₂} (φ : R ⟶ R'),
(CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution Φ L y).map φ =
CategoryTheory.CostructuredArrow.homMk (CategoryTheory.StructuredArrow.homMk φ.f ⋯) ⋯ |
descPochhammer_eval_eq_descFactorial | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k) |
ONote.NFBelow | Mathlib.SetTheory.Ordinal.Notation | ONote → Ordinal.{0} → Prop |
Units.instDecidableEq | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → [DecidableEq α] → DecidableEq αˣ |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3 | Mathlib.Analysis.Complex.Convex | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) |
OneHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [One M] → [One N] → [FunLike F M N] → Prop |
Std.Do.«term_∧ₚ_» | Std.Do.PostCond | Lean.TrailingParserDescr |
R0Space.closure_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker |
Fin.val_natCast | Mathlib.Data.Fin.Basic | ∀ (a n : ℕ) [inst : NeZero n], ↑↑a = a % n |
OneHom.coe_id | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} [inst : One M], ⇑(OneHom.id M) = id |
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α} {k : α},
l.contains k = false → (Std.DHashMap.Const.unitOfList l).getKey! k = default |
Finset.SupIndep.le_sup_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι},
s.SupIndep f → t ⊆ s → i ∈ s → (∀ (i : ι), f i ≠ ⊥) → (f i ≤ t.sup f ↔ i ∈ t) |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) |
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {p : β → Prop},
(∀ y ∈ f.range, p y) = ∀ (x : α), p (f x) |
_private.Mathlib.RingTheory.PowerSeries.Derivative.0.PowerSeries.derivativeFun_coe_mul_coe | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommSemiring R] (f g : Polynomial R),
(↑f * ↑g).derivativeFun = ↑f * ↑(Polynomial.derivative g) + ↑g * ↑(Polynomial.derivative f) |
TensorProduct.LieModule.map._proof_1 | Mathlib.Algebra.Lie.TensorProduct | ∀ {R : Type u_3} [inst : CommRing R] {L : Type u_6} {M : Type u_5} {N : Type u_4} {P : Type u_1} {Q : Type u_2}
[inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M]
[inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N]
[inst_9 : LieRingModule L N] [inst_10 : LieModule R L N] [inst_11 : AddCommGroup P] [inst_12 : Module R P]
[inst_13 : LieRingModule L P] [inst_14 : LieModule R L P] [inst_15 : AddCommGroup Q] [inst_16 : Module R Q]
[inst_17 : LieRingModule L Q] [inst_18 : LieModule R L Q] (f : M →ₗ⁅R,L⁆ P) (g : N →ₗ⁅R,L⁆ Q) {x : L}
{t : TensorProduct R M N}, (TensorProduct.map ↑f ↑g).toFun ⁅x, t⁆ = ⁅x, (TensorProduct.map ↑f ↑g).toFun t⁆ |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isValidForSlice | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice},
pat.isEmpty = false →
∀ {pos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat.copy.toByteArray s.copy.toByteArray
pat.utf8ByteSize pos.byteIdx →
String.Pos.Raw.IsValidForSlice s (pos.unoffsetBy pat.rawEndPos) → String.Pos.Raw.IsValidForSlice s pos |
ZeroHom.mk.noConfusion | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
{inst : Zero M} →
{inst_1 : Zero N} →
{P : Sort u} →
{toFun : M → N} →
{map_zero' : toFun 0 = 0} →
{toFun' : M → N} →
{map_zero'' : toFun' 0 = 0} →
{ toFun := toFun, map_zero' := map_zero' } = { toFun := toFun', map_zero' := map_zero'' } →
(toFun ≍ toFun' → P) → P |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x < y) = (x.toInt < y.toInt) |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.findAux.match_1.splitter | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) →
(motive : Batteries.UnionFind.FindAux self.size → Sort u_1) →
(x : Batteries.UnionFind.FindAux self.size) →
((arr₁ : Array Batteries.UFNode) →
(root : Fin self.size) → (H : arr₁.size = self.size) → motive { s := arr₁, root := root, size_eq := H }) →
motive x |
CategoryTheory.WithInitial.equivComma._proof_12 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
{X Y : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯, map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).map
f)
((fun F =>
CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯,
map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).obj
F))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun F =>
CategoryTheory.Iso.refl
(({ obj := CategoryTheory.WithInitial.ofCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.ofCommaMorphism, map_id := ⋯,
map_comp := ⋯ }.comp
{ obj := CategoryTheory.WithInitial.mkCommaObject,
map := fun {X Y} => CategoryTheory.WithInitial.mkCommaMorphism, map_id := ⋯, map_comp := ⋯ }).obj
F))
X).hom
((CategoryTheory.Functor.id
(CategoryTheory.Comma (CategoryTheory.Functor.const C)
(CategoryTheory.Functor.id (CategoryTheory.Functor C D)))).map
f) |
Aesop.RuleBuilderOptions.indexingMode? | Aesop.Builder.Basic | Aesop.RuleBuilderOptions → Option Aesop.IndexingMode |
Units.inv_mul_of_eq | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u = a → ↑u⁻¹ * a = 1 |
Nonneg.mk_smul | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : SMul R S] (a : R) (ha : 0 ≤ a)
(x : S), ⟨a, ha⟩ • x = a • x |
Set.preimage_singleton_eq_empty | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {y : β}, f ⁻¹' {y} = ∅ ↔ y ∉ Set.range f |
Set.isSimpleOrder_Iic_iff_isAtom | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
{X₁ X₂ X₃ Y₁ Y₂ Y₃ : P.FullSubcategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ObjectProperty.homMk
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.ObjectProperty.homMk (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁.hom f₂.hom)).hom
f₃.hom))
(P.fullyFaithfulι.preimageIso (CategoryTheory.MonoidalCategoryStruct.associator Y₁.obj Y₂.obj Y₃.obj)).hom =
CategoryTheory.CategoryStruct.comp
(P.fullyFaithfulι.preimageIso (CategoryTheory.MonoidalCategoryStruct.associator X₁.obj X₂.obj X₃.obj)).hom
(CategoryTheory.ObjectProperty.homMk
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁.hom
(CategoryTheory.ObjectProperty.homMk (CategoryTheory.MonoidalCategoryStruct.tensorHom f₂.hom f₃.hom)).hom)) |
Lean.Elab.Tactic.Conv.PatternMatchState.rec | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((subgoals : Array (ℕ × Lean.MVarId)) →
(idx : ℕ) →
(remaining : List (ℕ × ℕ)) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs subgoals idx remaining)) →
(t : Lean.Elab.Tactic.Conv.PatternMatchState) → motive t |
OrderMonoidHom.inrₗ | Mathlib.Algebra.Order.Monoid.Lex | (α : Type u_1) →
(β : Type u_2) →
[inst : Monoid α] → [inst_1 : PartialOrder α] → [inst_2 : Monoid β] → [inst_3 : Preorder β] → β →*o Lex (α × β) |
selfAdjoint.instField._proof_12 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : ℤ), ↑↑x = ↑↑x |
WithBot.map_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {β : Type u_1} (f : α → β), WithBot.map f 0 = ↑(f 0) |
ZeroHom.instModule._proof_1 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r • 0 = 0 |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.map_add_toList_rcc._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {n k : ℤ}, ¬n + 1 + k = n + k + 1 → False |
ConvexOn.lt_left_of_right_lt' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : Module 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s f →
∀ {x y : E},
x ∈ s → y ∈ s → ∀ {a b : 𝕜}, 0 < a → 0 < b → a + b = 1 → f y < f (a • x + b • y) → f (a • x + b • y) < f x |
Except.ctorIdx | Init.Prelude | {ε : Type u} → {α : Type v} → Except ε α → ℕ |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
AlgebraicGeometry.Scheme.basicOpen_le | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U |
CategoryTheory.Precoverage.mem_coverings_of_isIso | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S ⟶ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f ∈ J.coverings T |
Primrec.PrimrecBounded | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → {β : Type u_2} → [Primcodable α] → [Primcodable β] → (α → β) → Prop |
Order.Ideal.toLowerSet_injective | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet |
SimpleGraph.cliqueFinset_eq_empty_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : DecidableRel G.Adj] {n : ℕ},
G.cliqueFinset n = ∅ ↔ G.CliqueFree n |
LieAlgebra.IsExtension.range_eq_top | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N →ₗ⁅R⁆ L) {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], p.range = ⊤ |
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ (Type u_2))).map ε.left)
Y.hom =
CategoryTheory.CategoryStruct.comp X.hom ((CategoryTheory.Functor.fromPUnit A).map ε.right) |
Finset.Colex.toColex_sdiff_lt_toColex_sdiff' | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α} [inst_1 : DecidableEq α],
toColex (s \ t) < toColex (t \ s) ↔ toColex s < toColex t |
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | Lean.Parser.ParserAliasValue → Lean.Parser.ParserResolution |
HasSubset.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{t : HasSubset α} → {α' : Type u} → {t' : HasSubset α'} → α = α' → t ≍ t' → HasSubset.noConfusionType P t t' |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) → ((pre : Lean.Name) → motive (pre.str "inj")) → ((x : Lean.Name) → motive x) → motive declName |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C ⊕ C') |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), b ≤ a → (a - b).toNat = a.toNat - b.toNat |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.