name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Sym.mem_mk | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (a : α) (s : Multiset α) (h : s.card = n), a ∈ Sym.mk s h ↔ a ∈ s |
Std.Sat.AIG.RefVec.cast'.eq_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α} (s : aig1.RefVec len)
(h :
(∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig1.decls.size) →
∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig2.decls.size),
s.cast' h = { refs := s.refs, hrefs := ⋯ } |
_private.Init.Data.SInt.Lemmas.0.Int32.toISize_ne_minValue._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x = y) = (x.toInt = y.toInt) |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.mkBoxedVersion.match_1 | Lean.Compiler.LCNF.ExplicitBoxing | (motive :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) →
Sort u_1) →
(x :
Option
(Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure ×
Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure))) →
(Unit → motive none) →
((newParam : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
(s' : Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) → motive (some (newParam, s'))) →
motive x |
NumberField.IsCMField.mem_realUnits_iff | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ),
u ∈ NumberField.IsCMField.realUnits K ↔
∃ v,
(algebraMap (NumberField.RingOfIntegers ↥(NumberField.maximalRealSubfield K)) (NumberField.RingOfIntegers K)) ↑v =
↑u |
MonoidHom.fiberEquivKerOfSurjective._proof_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_2} [inst : Group α] {H : Type u_1} [inst_1 : Group H] {f : α →* H} (hf : Function.Surjective ⇑f) (h : H),
f ⋯.choose = h |
Std.TreeMap.Raw.getElem!_union_of_not_mem_right | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst : Inhabited β], k ∉ t₂ → (t₁ ∪ t₂)[k]! = t₁[k]! |
Subarray.get! | Init.Data.Array.Subarray | {α : Type u_1} → [Inhabited α] → Subarray α → ℕ → α |
Mathlib.Tactic.ITauto.IProp.ctorElim | Mathlib.Tactic.ITauto | {motive : Mathlib.Tactic.ITauto.IProp → Sort u} →
(ctorIdx : ℕ) →
(t : Mathlib.Tactic.ITauto.IProp) →
ctorIdx = t.ctorIdx → Mathlib.Tactic.ITauto.IProp.ctorElimType ctorIdx → motive t |
Ordering | Init.Data.Ord.Basic | Type |
List.Cursor | Std.Do.Triple.SpecLemmas | {α : Type u} → List α → Type u |
Stream'.WSeq.drop.aux_none | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (n : ℕ), Stream'.WSeq.drop.aux n none = Computation.pure none |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.Seq.BisimO.match_1.splitter | Mathlib.Data.WSeq.Basic | {α : Type u_1} →
(motive : Option (Stream'.Seq1 α) → Option (Stream'.Seq1 α) → Sort u_2) →
(x x_1 : Option (Stream'.Seq1 α)) →
(Unit → motive none none) →
((a : α) → (s : Stream'.Seq α) → (a' : α) → (s' : Stream'.Seq α) → motive (some (a, s)) (some (a', s'))) →
((x x_2 : Option (Stream'.Seq1 α)) →
(x = none → x_2 = none → False) →
(∀ (a : α) (s : Stream'.Seq α) (a' : α) (s' : Stream'.Seq α),
x = some (a, s) → x_2 = some (a', s') → False) →
motive x x_2) →
motive x x_1 |
Std.Rci.rec | Init.Data.Range.Polymorphic.PRange | {α : Type u} → {motive : Std.Rci α → Sort u_1} → ((lower : α) → motive lower...*) → (t : Std.Rci α) → motive t |
MultilinearMap.freeFinsuppEquiv._proof_4 | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) |
supIrred_ofDual | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : αᵒᵈ}, SupIrred (OrderDual.ofDual a) ↔ InfIrred a |
NonUnitalSeminormedRing.rec | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
{motive : NonUnitalSeminormedRing α → Sort u} →
([toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toPseudoMetricSpace : PseudoMetricSpace α] →
(dist_eq : ∀ (x y : α), dist x y = ‖-x + y‖) →
(norm_mul_le : ∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) →
motive
{ toNorm := toNorm, toNonUnitalRing := toNonUnitalRing, toPseudoMetricSpace := toPseudoMetricSpace,
dist_eq := dist_eq, norm_mul_le := norm_mul_le }) →
(t : NonUnitalSeminormedRing α) → motive t |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.isUnit_resultant_iff_isCoprime.match_1_4 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] {f g : Polynomial R} (motive : IsCoprime f g → Prop) (h : IsCoprime f g),
(∀ (a b : Polynomial R) (e : a * f + b * g = 1), motive ⋯) → motive h |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.axiom.formatter_105 | Lean.Parser.Command | IO Unit |
AddCommGrpCat.ofHom_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddCommGrpCat} (f : X ⟶ Y), AddCommGrpCat.ofHom (AddCommGrpCat.Hom.hom f) = f |
CategoryTheory.Grothendieck.functorFrom_obj | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{E : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} E] (fib : (c : C) → CategoryTheory.Functor (↑(F.obj c)) E)
(hom : {c c' : C} → (f : c ⟶ c') → fib c ⟶ (F.map f).toFunctor.comp (fib c'))
(hom_id : ∀ (c : C), hom (CategoryTheory.CategoryStruct.id c) = CategoryTheory.eqToHom ⋯)
(hom_comp :
∀ (c₁ c₂ c₃ : C) (f : c₁ ⟶ c₂) (g : c₂ ⟶ c₃),
hom (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (hom f)
(CategoryTheory.CategoryStruct.comp ((F.map f).toFunctor.whiskerLeft (hom g)) (CategoryTheory.eqToHom ⋯)))
(X : CategoryTheory.Grothendieck F),
(CategoryTheory.Grothendieck.functorFrom fib hom hom_id hom_comp).obj X = (fib X.base).obj X.fiber |
CategoryTheory.Free.of | Mathlib.Algebra.Category.ModuleCat.Adjunctions | (R : Type u_1) → {C : Type u} → C → CategoryTheory.Free R C |
Mathlib.Tactic.Widget.StringDiagram.IdNode | Mathlib.Tactic.Widget.StringDiagram | Type |
Topology.IsConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsOpenEmbedding f → Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) |
Hashable.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Sort u} →
{t : Hashable α} → {α' : Sort u} → {t' : Hashable α'} → α = α' → t ≍ t' → Hashable.noConfusionType P t t' |
ProbabilityTheory.HasGaussianLaw.toLp_prodMk | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] [BorelSpace F] {Y : Ω → F}
[SecondCountableTopologyEither E F] (p : ENNReal) [inst_9 : Fact (1 ≤ p)],
ProbabilityTheory.HasGaussianLaw (fun ω => (X ω, Y ω)) P →
ProbabilityTheory.HasGaussianLaw (fun ω => WithLp.toLp p (X ω, Y ω)) P |
Std.ExtTreeMap.minKey?_insertIfNew_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true |
convexIndependent_iff_notMem_convexHull_diff | Mathlib.Analysis.Convex.Independent | ∀ {𝕜 : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] {p : ι → E},
ConvexIndependent 𝕜 p ↔ ∀ (i : ι) (s : Set ι), p i ∉ (convexHull 𝕜) (p '' (s \ {i})) |
FreeGroup.freeGroupEmptyEquivUnit._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | Function.LeftInverse (fun x => 1) fun x => () |
Qq.QuotedDefEq.unsafeIntro | Qq.Typ | ∀ {u : Lean.Level} {α : Q(Sort u)} {lhs rhs : Q(«$α»)}, «$lhs» =Q «$rhs» |
_private.Batteries.Data.Char.AsciiCasing.0.Char.not_isLower_of_isUpper._simp_1_2 | Batteries.Data.Char.AsciiCasing | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) |
TopCat.isInitialPEmpty._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ (X : TopCat) (f : TopCat.of PEmpty.{u_1 + 1} ⟶ X), f = default |
Nat.boddDiv2 | Mathlib.Data.Nat.Bits | ℕ → Bool × ℕ |
CategoryTheory.Functor.closedIhom_map_app | Mathlib.CategoryTheory.Monoidal.Closed.FunctorCategory.Groupoid | ∀ {D : Type u} {C : Type u_1} [inst : CategoryTheory.Groupoid D] [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
(F : CategoryTheory.Functor D C) {X Y : CategoryTheory.Functor D C} (g : X ⟶ Y) (X_1 : D),
(F.closedIhom.map g).app X_1 = (CategoryTheory.ihom (F.obj X_1)).map (g.app X_1) |
RelSeries.subsingleton_of_length_eq_zero | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r}, s.length = 0 → {x | x ∈ s}.Subsingleton |
MDifferentiableAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_11}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_12} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_13} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{F' : Type u_14} [inst_16 : NormedAddCommGroup F'] [inst_17 : NormedSpace 𝕜 F'] {G' : Type u_15}
[inst_18 : TopologicalSpace G'] {J' : ModelWithCorners 𝕜 F' G'} {N' : Type u_16} [inst_19 : TopologicalSpace N']
[inst_20 : ChartedSpace G' N'] {f : M → M'} {g : N → N'} {p : M × N},
MDiffAt f p.1 → MDiffAt g p.2 → MDiffAt (Prod.map f g) p |
Equiv.nonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocSemiring β] (x y : α),
e (e.symm (e x + e y)) = e x + e y |
Filter.bot_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {g : Filter α}, ⊥ / g = ⊥ |
Real.Angle.two_nsmul_eq_pi_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = ↑Real.pi ↔ θ = ↑(Real.pi / 2) ∨ θ = ↑(-Real.pi / 2) |
BitVec.ofBoolListLE._sunfold | Init.Data.BitVec.Basic | (bs : List Bool) → BitVec bs.length |
Plausible.Gen.listOf | Plausible.Gen | {α : Type u} → Plausible.Gen α → Plausible.Gen (List α) |
Order.succ_eq_succ_iff._simp_2 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
(Order.succ a = Order.succ b) = (a = b) |
MeasureTheory.meas_le_ae_eq_meas_lt | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {R : Type u_3} [inst_1 : LinearOrder R]
[inst_2 : MeasurableSpace R] (ν : MeasureTheory.Measure R) [MeasureTheory.NoAtoms ν] (g : α → R),
(fun t => μ {a | t ≤ g a}) =ᵐ[ν] fun t => μ {a | t < g a} |
AddConstEquiv.instEquivLike._proof_2 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} (f : AddConstEquiv G H a b),
Function.RightInverse f.invFun f.toFun |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.StructInstState.mk.noConfusion | Lean.Elab.StructInst | {P : Sort u} →
{type : Lean.Expr} →
{structNameSet : Lean.NameSet} →
{fieldMap : Lean.NameMap Lean.Expr} →
{fields : Array Lean.Expr} →
{instMVars : Array Lean.MVarId} →
{liftedFVars : Array Lean.Expr} →
{liftedFVarRemap : Lean.FVarIdMap Lean.FVarId} →
{optParamFields : Array (Lean.Name × Lean.Expr × Bool)} →
{type' : Lean.Expr} →
{structNameSet' : Lean.NameSet} →
{fieldMap' : Lean.NameMap Lean.Expr} →
{fields' : Array Lean.Expr} →
{instMVars' : Array Lean.MVarId} →
{liftedFVars' : Array Lean.Expr} →
{liftedFVarRemap' : Lean.FVarIdMap Lean.FVarId} →
{optParamFields' : Array (Lean.Name × Lean.Expr × Bool)} →
{ type := type, structNameSet := structNameSet, fieldMap := fieldMap,
fields := fields, instMVars := instMVars, liftedFVars := liftedFVars,
liftedFVarRemap := liftedFVarRemap, optParamFields := optParamFields } =
{ type := type', structNameSet := structNameSet', fieldMap := fieldMap',
fields := fields', instMVars := instMVars', liftedFVars := liftedFVars',
liftedFVarRemap := liftedFVarRemap', optParamFields := optParamFields' } →
(type = type' →
structNameSet = structNameSet' →
fieldMap = fieldMap' →
fields = fields' →
instMVars = instMVars' →
liftedFVars = liftedFVars' →
liftedFVarRemap = liftedFVarRemap' →
optParamFields = optParamFields' → P) →
P |
PNat.gcdB' | Mathlib.Data.PNat.Xgcd | ℕ+ → ℕ+ → ℕ+ |
retractionKerCotangentToTensorEquivSection.match_3 | Mathlib.RingTheory.Smooth.Kaehler | {R : Type u_3} →
{P : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing P] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R P] →
[inst_4 : Algebra P S] →
let P' := P ⧸ RingHom.ker (algebraMap P S) ^ 2;
(motive : { l // l ∘ₗ KaehlerDifferential.kerToTensor R P' S = LinearMap.id } → Sort u_4) →
(x : { l // l ∘ₗ KaehlerDifferential.kerToTensor R P' S = LinearMap.id }) →
((l : TensorProduct P' S Ω[P'⁄R] →ₗ[P'] ↥(RingHom.ker (algebraMap P' S))) →
(hl : l ∘ₗ KaehlerDifferential.kerToTensor R P' S = LinearMap.id) → motive ⟨l, hl⟩) →
motive x |
Int8.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | ∀ (n : BitVec 8), Int8.minValue.toInt ≤ n.toInt |
MeasureTheory.lintegral_comp_eq_lintegral_meas_lt_mul | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℝ} {g : ℝ → ℝ} (μ : MeasureTheory.Measure α),
0 ≤ᵐ[μ] f →
AEMeasurable f μ →
(∀ t > 0, IntervalIntegrable g MeasureTheory.volume 0 t) →
(∀ᵐ (t : ℝ) ∂MeasureTheory.volume.restrict (Set.Ioi 0), 0 ≤ g t) →
∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0..f ω, g t) ∂μ =
∫⁻ (t : ℝ) in Set.Ioi 0, μ {a | t < f a} * ENNReal.ofReal (g t) |
CategoryTheory.Monad.forget_map | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {X Y : T.Algebra} (f : X ⟶ Y),
T.forget.map f = f.f |
LinearMap.range_domRestrict_eq_range_iff | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M},
(f.domRestrict S).range = f.range ↔ S ⊔ f.ker = ⊤ |
Lean.Parser.Command.grindPattern.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t = ∅) |
_private.Init.Data.List.Sort.Basic.0.List.merge._unary._proof_2 | Init.Data.List.Sort.Basic | ∀ {α : Type u_1} (x : α) (xs : List α) (y : α) (ys : List α),
(invImage (fun x => PSigma.casesOn x fun xs ys => (xs, ys)) Prod.instWellFoundedRelation).1 ⟨xs, y :: ys⟩
⟨x :: xs, y :: ys⟩ |
_private.Mathlib.Data.ENat.Basic.0.ENat.WithBot.lt_add_one_iff._simp_1_2 | Mathlib.Data.ENat.Basic | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True |
RelIso.casesOn | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{motive : r ≃r s → Sort u} →
(t : r ≃r s) →
((toEquiv : α ≃ β) →
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b) →
motive { toEquiv := toEquiv, map_rel_iff' := map_rel_iff' }) →
motive t |
TensorProduct.AlgebraTensorModule.rightComm._proof_8 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (S : Type u_2) (M : Type u_3) (P : Type u_4) (Q : Type u_5) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R Q] [inst_6 : CommSemiring S] [inst_7 : Module S M] [inst_8 : Module S P]
[inst_9 : SMulCommClass R S M] [inst_10 : SMulCommClass S R M],
SMulCommClass R S (TensorProduct S (TensorProduct R M Q) P) |
Lean.Elab.WF.GuessLex.withUserNames | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} → Array Lean.Expr → Array Lean.Name → Lean.MetaM α → Lean.MetaM α |
Subgroup.coe_square | Mathlib.Algebra.Group.Subgroup.Even | ∀ {G : Type u_1} [inst : CommGroup G], ↑(Subgroup.square G) = {s | IsSquare s} |
Lean.Meta.Grind.Arith.Cutsat.instHashableExpr_lean.hash | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Int.Linear.Expr → UInt64 |
Aesop.UnfoldRule.mk.injEq | Aesop.Rule | ∀ (decl : Lean.Name) (unfoldThm? : Option Lean.Name) (decl_1 : Lean.Name) (unfoldThm?_1 : Option Lean.Name),
({ decl := decl, unfoldThm? := unfoldThm? } = { decl := decl_1, unfoldThm? := unfoldThm?_1 }) =
(decl = decl_1 ∧ unfoldThm? = unfoldThm?_1) |
String.Slice.Pattern.Model.IsValidSearchFrom.matched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
String.Slice.Pattern.Model.IsLongestMatchAt pat startPos' endPos →
startPos = startPos' →
String.Slice.Pattern.Model.IsValidSearchFrom pat startPos'
(String.Slice.Pattern.SearchStep.matched startPos endPos :: l) |
EReal.mul_div_left_comm | Mathlib.Data.EReal.Inv | ∀ (a b c : EReal), a * (b / c) = b * (a / c) |
LieHom.mk.congr_simp | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (toLinearMap toLinearMap_1 : L →ₗ[R] L')
(e_toLinearMap : toLinearMap = toLinearMap_1)
(map_lie' : ∀ {x y : L}, toLinearMap.toFun ⁅x, y⁆ = ⁅toLinearMap.toFun x, toLinearMap.toFun y⁆),
{ toLinearMap := toLinearMap, map_lie' := map_lie' } = { toLinearMap := toLinearMap_1, map_lie' := ⋯ } |
Std.DHashMap.Internal.Raw₀.erase_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α}, (↑(m₁.erase k)).Equiv ↑(m₂.erase k) |
Nat.mem_primeFactorsList_mul | Mathlib.Data.Nat.Factors | ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → ∀ {p : ℕ}, p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList |
InnerProductSpace.Core.toNormedAddCommGroupOfTopology | Mathlib.Analysis.InnerProductSpace.Defs | {𝕜 : Type u_1} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] →
[cd : InnerProductSpace.Core 𝕜 F] →
[tF : TopologicalSpace F] →
[IsTopologicalAddGroup F] →
[ContinuousConstSMul 𝕜 F] →
ContinuousAt (fun v => inner 𝕜 v v) 0 →
Bornology.IsVonNBounded 𝕜 {v | RCLike.re (inner 𝕜 v v) < 1} → NormedAddCommGroup F |
finsum_sum_comm | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (s : Finset β) (f : α → β → M),
(∀ b ∈ s, Function.HasFiniteSupport fun a => f a b) → ∑ᶠ (a : α), ∑ b ∈ s, f a b = ∑ b ∈ s, ∑ᶠ (a : α), f a b |
AddCommGrpCat.Colimits.Quot.ι_desc | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(c : CategoryTheory.Limits.Cocone F) [inst_1 : DecidableEq J] (j : J) (x : ↑(F.obj j)),
(AddCommGrpCat.Colimits.Quot.desc F c) ((AddCommGrpCat.Colimits.Quot.ι F j) x) =
(CategoryTheory.ConcreteCategory.hom (c.ι.app j)) x |
CategoryTheory.ShortComplex.cyclesFunctorIso._proof_3 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.Limits.HasCokernels C]
[F.PreservesHomology] {Y : CategoryTheory.ShortComplex C}, (Y.map F).HasLeftHomology |
Lean.Grind.OrderedAdd.zsmul_le_zsmul | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{a b : M} {k : ℤ}, 0 ≤ k → a ≤ b → k • a ≤ k • b |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_union_of_contains_eq_false_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Array.mem_flatten_of_mem | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xss : Array (Array α)} {xs : Array α} {a : α}, xs ∈ xss → a ∈ xs → a ∈ xss.flatten |
CategoryTheory.ShortComplex.HomologyData.ofIsIsoLeftRightHomologyComparison' | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
(h₁ : S.LeftHomologyData) →
(h₂ : S.RightHomologyData) →
[CategoryTheory.IsIso (CategoryTheory.ShortComplex.leftRightHomologyComparison' h₁ h₂)] → S.HomologyData |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.Style.header.collectAtoms._unsafe_rec | Mathlib.Tactic.Linter.Header | Lean.Syntax → Array String |
Aesop.Nanos.mk | Aesop.Nanos | ℕ → Aesop.Nanos |
AlgebraicGeometry.functionField_isFractionRing_of_isAffineOpen | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsIntegral X] (U : X.Opens),
AlgebraicGeometry.IsAffineOpen U →
∀ [inst_1 : Nonempty ↥↑U], IsFractionRing ↑(X.presheaf.obj (Opposite.op U)) ↑X.functionField |
CategoryTheory.Functor.final_const_terminal | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsFiltered C] [inst_3 : CategoryTheory.Limits.HasTerminal D],
((CategoryTheory.Functor.const C).obj (⊤_ D)).Final |
CategoryTheory.Sieve.sSup_apply | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C}
(f : Y ⟶ X), (sSup Ss).arrows f ↔ ∃ S, ∃ (_ : S ∈ Ss), S.arrows f |
Int.lt_of_add_lt_add_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, a + b < a + c → b < c |
Polynomial.natDegree_eq_card_roots | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [inst_1 : IsDomain R], f.Splits → f.natDegree = f.roots.card |
_private.Mathlib.RingTheory.Binomial.0.Ring.smeval_ascPochhammer_self_neg.match_1_1 | Mathlib.RingTheory.Binomial | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x |
Algebra.adjoin_singleton_natCast | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (n : ℕ),
Algebra.adjoin R {↑n} = ⊥ |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid.match_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
(motive : (x : WithTop G) → x ≠ ⊤ → Prop) (x : WithTop G) (x_1 : x ≠ ⊤),
(∀ (a : G) (x : ↑a ≠ ⊤), motive (some a) x) → motive x x_1 |
ProjectiveSpectrum.zeroLocus_iSup_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {γ : Sort u_3} (I : γ → HomogeneousIdeal 𝒜),
ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i) |
_private.Lean.Elab.PreDefinition.EqUnfold.0.Lean.Meta.initFn.match_3._@.Lean.Elab.PreDefinition.EqUnfold.1356299382._hygCtx._hyg.2 | Lean.Elab.PreDefinition.EqUnfold | (motive : Lean.Name → Sort u_1) →
(name : Lean.Name) → ((p : Lean.Name) → (s : String) → motive (p.str s)) → ((x : Lean.Name) → motive x) → motive name |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_one | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 1 =
CategoryTheory.CategoryStruct.id ((CategoryTheory.ComposableArrows.mk₃ f₁₂ f₃ f₄).obj 1) |
SimpleGraph.replaceVertex.eq_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V) [inst : DecidableEq V],
G.replaceVertex s t =
{ Adj := fun v w => if v = t then if w = t then False else G.Adj s w else if w = t then G.Adj v s else G.Adj v w,
symm := ⋯, loopless := ⋯ } |
Vector.ne_and_not_mem_of_not_mem_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a y : α} {xs : Vector α n}, a ∉ xs.push y → a ≠ y ∧ a ∉ xs |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.getTheorems | Lean.Elab.Tactic.Grind.Lint | Option (Array Lean.Name) → Bool → Lean.CoreM (List Lean.Name) |
Lean.Elab.Term.Do.instInhabitedCode | Lean.Elab.Do.Legacy | Inhabited Lean.Elab.Term.Do.Code |
Std.DHashMap.Internal.Raw.Const.get_eq._proof_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u_1} {β : Type u_2} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, 0 < m.buckets.size |
List.mapFinIdx.go | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(as : List α) →
((i : ℕ) → α → i < as.length → β) → (bs : List α) → (acc : Array β) → bs.length + acc.size = as.length → List β |
MonoidHom.injective_codRestrict._simp_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f |
_private.Aesop.Tree.Data.0.Aesop.GoalOrigin.originalGoalId?._sparseCasesOn_1 | Aesop.Tree.Data | {motive : Aesop.GoalOrigin → Sort u} →
(t : Aesop.GoalOrigin) →
((«from» rep : Aesop.GoalId) → motive (Aesop.GoalOrigin.copied «from» rep)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
OrderIso.isCoatom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderTop α]
[inst_3 : OrderTop β] (f : α ≃o β) (a : α), IsCoatom (f a) ↔ IsCoatom a |
Std.DHashMap.Internal.Raw₀.Const.getD_diff_of_contains_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β},
m₂.contains k = true → Std.DHashMap.Internal.Raw₀.Const.getD (m₁.diff m₂) k fallback = fallback |
MeasureTheory.addContent_eq_add_disjointOfDiffUnion_of_subset | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {C : Set (Set α)} {s : Set α} {I : Finset (Set α)} {G : Type u_2} [inst : AddCommMonoid G]
{m : MeasureTheory.AddContent G C} (hC : MeasureTheory.IsSetSemiring C) (hs : s ∈ C) (hI : ↑I ⊆ C),
(∀ t ∈ I, t ⊆ s) → (↑I).PairwiseDisjoint id → m s = ∑ i ∈ I, m i + ∑ i ∈ hC.disjointOfDiffUnion hs hI, m i |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.IsAtomic.realize_comp_of_injective._simp_1_4 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
{k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term (α ⊕ Fin l)},
(R.boundedFormula ts).Realize v xs =
FirstOrder.Language.Structure.RelMap R fun i => FirstOrder.Language.Term.realize (Sum.elim v xs) (ts i) |
Std.DTreeMap.Internal.RcoSliceData.mk.injEq | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rco α)
(treeMap_1 : Std.DTreeMap.Internal.Impl α β) (range_1 : Std.Rco α),
({ treeMap := treeMap, range := range } = { treeMap := treeMap_1, range := range_1 }) =
(treeMap = treeMap_1 ∧ range = range_1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.