name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
integral_sin_pow_aux | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ} (n : ℕ),
∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) =
(Real.sin a ^ (n + 1) * Real.cos a - Real.sin b ^ (n + 1) * Real.cos b +
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ n) -
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) | true |
Lean.Parser.Term.stateRefT._regBuiltin.Lean.Parser.Term.stateRefT_1 | Lean.Parser.Term | IO Unit | false |
thickenedIndicator.congr_simp | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {δ δ_1 : ℝ} (e_δ : δ = δ_1) (δ_pos : 0 < δ) (E E_1 : Set α),
E = E_1 → thickenedIndicator δ_pos E = thickenedIndicator ⋯ E_1 | true |
Representation.Coinvariants.mk_tmul_inv | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tpr... | true |
Finpartition.ofErase.congr_simp | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a : α} (parts parts_1 : Finset α)
(e_parts : parts = parts_1) (sup_indep : parts.SupIndep id) (sup_parts : parts.sup id = a),
Finpartition.ofErase parts sup_indep sup_parts = Finpartition.ofErase parts_1 ⋯ ⋯ | true |
ClassGroup.mk._proof_1 | Mathlib.RingTheory.ClassGroup | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], (toPrincipalIdeal R (FractionRing R)).range.Normal | false |
NonarchimedeanGroup.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
(Continuous fun p => p.1 * p.2) → (Continuous fun a => a⁻¹) → (∀ U ∈ nhds 1, ∃ V, ↑V ⊆ U) → NonarchimedeanGroup G | false |
Lean.Name.hasMacroScopes._unsafe_rec | Init.Prelude | Lean.Name → Bool | false |
Lean.Diff.Action.skip | Lean.Util.Diff | Lean.Diff.Action | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ofNat_sub_ofNat_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → ¬2 ^ w - y + x = 2 ^ w + (x - y) → False | false |
instMinInt16 | Init.Data.SInt.Basic | Min Int16 | true |
MeasureTheory.OuterMeasure.instLawfulFunctor | Mathlib.MeasureTheory.OuterMeasure.Operations | LawfulFunctor MeasureTheory.OuterMeasure | true |
NonemptyFinLinOrd.hom_hom_ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ {X Y : Type u} [inst : Nonempty X] [inst_1 : LinearOrder X] [inst_2 : Fintype X] [inst_3 : Nonempty Y]
[inst_4 : LinearOrder Y] [inst_5 : Fintype Y] (f : X →o Y), LinOrd.Hom.hom (NonemptyFinLinOrd.ofHom f).hom = f | true |
ProbabilityTheory.condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | {α : Type u_1} → {mα : MeasurableSpace α} → MeasureTheory.Measure (α × ℝ) → α → StieltjesFunction ℝ | true |
ExceptCpsT.runCatch | Init.Control.ExceptCps | {m : Type u_1 → Type u_2} → {α : Type u_1} → [Monad m] → ExceptCpsT α m α → m α | true |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.mk.injEq | Lean.Widget.Diff | ∀ (changesBefore changesAfter changesBefore_1 changesAfter_1 : Lean.SubExpr.PosMap Lean.Widget.ExprDiffTag✝),
({ changesBefore := changesBefore, changesAfter := changesAfter } =
{ changesBefore := changesBefore_1, changesAfter := changesAfter_1 }) =
(changesBefore = changesBefore_1 ∧ changesAfter = changesA... | true |
Lean.Compiler.LCNF.FloatLetIn.Decision.recOn | Lean.Compiler.LCNF.FloatLetIn | {motive : Lean.Compiler.LCNF.FloatLetIn.Decision → Sort u} →
(t : Lean.Compiler.LCNF.FloatLetIn.Decision) →
((name : Lean.Name) → motive (Lean.Compiler.LCNF.FloatLetIn.Decision.arm name)) →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.default →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.dont →
... | false |
Seminorm.instSeminormClass | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E],
SeminormClass (Seminorm 𝕜 E) 𝕜 E | true |
AddCircle.denseRange_zsmul_iff | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {p : ℝ} [Fact (0 < p)] {a : AddCircle p}, (DenseRange fun x => x • a) ↔ addOrderOf a = 0 | true |
Multiset.equivDFinsupp._proof_2 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α], Multiset.toDFinsupp.comp DFinsupp.toMultiset = AddMonoidHom.id (Π₀ (x : α), ℕ) | false |
Std.HashMap.Raw.getKeyD_inter_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getKeyD k fallback = fallback | true |
MeasureTheory.LocallyIntegrable.integrable_of_isBigO_atTop_of_norm_isNegInvariant | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F}
[inst_1 : TopologicalSpace α] [SecondCountableTopology α] [inst_3 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_4 : NormedAddCommGroup F] [inst_5 : AddCommGroup α] [inst_6 : LinearOrder α] [IsOrderedAddMo... | true |
Representation.norm_self_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : AddCommMonoid V] [inst_4 : Module k V] (ρ : Representation k G V) (g : G) (x : V),
ρ.norm ((ρ g) x) = ρ.norm x | true |
WithCStarModule.instUnique | Mathlib.Analysis.CStarAlgebra.Module.Synonym | (A : Type u_3) → (E : Type u_4) → [Unique E] → Unique (WithCStarModule A E) | true |
CategoryTheory.Lax.OplaxTrans.vCompApp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.LaxFunctor B C} →
CategoryTheory.Lax.OplaxTrans F G → CategoryTheory.Lax.OplaxTrans G H → (a : B) → F.obj a ⟶ H.obj a | true |
TrivSqZeroExt.instL1SeminormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : SeminormedRing R] [inst_1 : SeminormedAddCommGroup M] (x y : TrivSqZeroExt R M),
dist x y = ‖-x + y‖ | false |
Algebra.adjoin_empty | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A], R[] = ⊥ | true |
LinearMap.intrinsicStar_mulRight | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : InvolutiveStar R] {E : Type u_6} [inst_2 : NonUnitalNonAssocSemiring E]
[inst_3 : StarRing E] [inst_4 : Module R E] [inst_5 : StarModule R E] [inst_6 : SMulCommClass R E E]
[inst_7 : IsScalarTower R E E] (x : E),
star (WithConv.toConv (LinearMap.mulRight R x)) = With... | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.le_iff_compatible_subset_subset.match_1_1 | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {G H : Graph α β}
(motive : G.Compatible H ∧ G.vertexSet ⊆ H.vertexSet ∧ G.edgeSet ⊆ H.edgeSet → Prop)
(x : G.Compatible H ∧ G.vertexSet ⊆ H.vertexSet ∧ G.edgeSet ⊆ H.edgeSet),
(∀ (h : G.Compatible H) (hV : G.vertexSet ⊆ H.vertexSet) (hE : G.edgeSet ⊆ H.edgeSet), motive ⋯) → motive... | false |
Finsupp.prod_of_support_subset | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] (f : α →₀ M) {s : Finset α},
f.support ⊆ s → ∀ (g : α → M → N), (∀ i ∈ s, g i 0 = 1) → f.prod g = ∏ x ∈ s, g x (f x) | true |
Lean.Meta.Grind.propagateEqUp | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator | true |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.instIsTruncGENatIntEmbeddingUpIntGE._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p : ℤ) {j : ℕ} {x : ℤ}, p + ↑j + 1 = x → p + (↑j + 1) = x | false |
CochainComplex.mappingCone.mapHomologicalComplexXIso' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Category.{v', u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{F G : CochainComplex C ℤ} →
(φ : F ⟶ G) →
... | true |
CategoryTheory.Limits.wideCoequalizerIsWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : J → (X ⟶ Y)) →
[inst_1 : CategoryTheory.Limits.HasWideCoequalizer f] →
[inst_2 : Nonempty J] →
CategoryTheory.Limits.IsColimit
(CategoryTheory.Limits.Cotride... | true |
length_permsOfList | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), (permsOfList l).length = l.length.factorial | true |
CategoryTheory.ShortComplex.RightHomologyMapData.noConfusion | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
... | false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_10 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
Std.DHashMap.Const.foldM_eq_foldlM_toList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {δ : Type w} {m' : Type w → Type w'} {β : Type v}
{m : Std.DHashMap α fun x => β} [inst : Monad m'] [LawfulMonad m'] {f : δ → α → β → m' δ} {init : δ},
Std.DHashMap.foldM f init m = List.foldlM (fun a b => f a b.1 b.2) init (Std.DHashMap.Const.toList m) | true |
Bundle.Trivial.vectorBundle | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B], VectorBundle 𝕜 F (Bundle.Trivial B F) | true |
ModularGroup.exists_bound_of_subgroup_invariant | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {f : UpperHalfPlane → E},
Continuous f →
(∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ), UpperHalfPlane.IsBoundedAtImInfty fun τ => f (g • τ)) →
∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.IsArithmetic],
(∀ g ∈ Γ, ∀ (τ : UpperHalfPlane), f (g • τ) = f τ) → ∃ C... | true |
CategoryTheory.Functor.IsOneHypercoverDense.of_hasPullbacks | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.Functor.IsDenseSubsite J₀ J F]
[CategoryTheory.Limits.H... | true |
NonUnitalSubalgebra.coe_zero | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{S : NonUnitalSubalgebra R A}, ↑0 = 0 | true |
Fin.insertNthOrderIso_symm_apply | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)] (p : Fin (n + 1))
(f : (i : Fin (n + 1)) → α i), (RelIso.symm (Fin.insertNthOrderIso α p)) f = (f p, p.removeNth f) | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Reify.0.Lean.Meta.Grind.Arith.CommRing.reifyCore?.go | Lean.Meta.Tactic.Grind.Arith.CommRing.Reify | {m : Type → Type} →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadError m] →
[Monad m] →
[Lean.Meta.Grind.Arith.CommRing.MonadCanon m] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing m] →
(Lean.Expr → m Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(Lean.Expr → m Lean.Meta.Grin... | true |
IntermediateField.relfinrank_eq_one_iff | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.relfinrank B = 1 ↔ B ≤ A | true |
groupCohomology.isoCocycles₂._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) 2).HasLeftHomology | false |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Vector.0.Vector.iterM_equiv_iterM_toList._simp_1_1 | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {n : ℕ} {xs : Vector β n}, xs.iterM m = xs.toArray.iterM m | false |
_private.Mathlib.CategoryTheory.Subfunctor.Equalizer.0.CategoryTheory.Subfunctor.equalizer.condition._simp_1_1 | Mathlib.CategoryTheory.Subfunctor.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)}
{A : CategoryTheory.Subfunctor F₁} (f g : A.toFunctor ⟶ F₂) {G : CategoryTheory.Functor C (Type w)}
(φ : G ⟶ A.toFunctor),
(CategoryTheory.CategoryStruct.comp φ f = CategoryTheory.CategoryStruct.comp φ g) =
(C... | false |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_2 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_26 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (hp₀ : ¬p₀ = s.endPos) (q : s.Pos) (v : ℕ),
Lean.parseLowerHex?✝ 4 s (p₀.next hp₀) 0 = some (q, v) → p₀ < q | false |
RingHom.codRestrict._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σS : Type u_2}
[inst_2 : SetLike σS S] [inst_3 : SubsemiringClass σS S] (f : R →+* S) (s : σS) (h : ∀ (x : R), f x ∈ s) (x y : R),
(↑((↑f).codRestrict s h)).toFun (x * y) = (↑((↑f).codRestrict s h)).toFun x * (↑((↑f).codRestr... | false |
Lean.Meta.DiscrTree.recOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t | false |
_private.Mathlib.GroupTheory.Sylow.0.Sylow.exists_subgroup_card_pow_prime.match_1_1 | Mathlib.GroupTheory.Sylow | ∀ {G : Type u_1} [inst : Group G] (p : ℕ) {n : ℕ} (motive : (∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K) → Prop)
(x : ∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), (∀ (K : Subgroup G) (hK : Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), motive ⋯) → motive x | false |
MeasureTheory.condExp_of_not_integrable | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → E}
[inst : NormedAddCommGroup E] [inst_1 : CompleteSpace E] [inst_2 : NormedSpace ℝ E],
¬MeasureTheory.Integrable f μ → μ[f | m] = 0 | true |
Matrix.toLin_finTwoProd_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] [inst : CompleteSpace 𝕜] (a b c d : 𝕜),
LinearMap.toContinuousLinearMap
((Matrix.toLin (Module.Basis.finTwoProd 𝕜) (Module.Basis.finTwoProd 𝕜)) !![a, b; c, d]) =
(a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
... | true |
Int16.toBitVec_add | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b).toBitVec = a.toBitVec + b.toBitVec | true |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_3 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
MatrixEquivTensor.toFunAlgHom._proof_3 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq n] [inst_4 : Fintype n], (MatrixEquivTensor.toFunLinear n R A) (1 ⊗ₜ[R] 1) = 1 | false |
Std.DHashMap.Raw.Const.getD_of_isEmpty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a : α} {fallback : β}, m.isEmpty = true → Std.DHashMap.Raw.Const.getD m a fallback = fallback | true |
SemilinearMapClass.mk._flat_ctor | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} [inst : Semiring R] [inst_1 : Semiring S]
{σ : outParam (R →+* S)} {M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} [inst_2 : AddCommMonoid M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] [inst_6 : FunLike F M ... | false |
RootPairing.IsRootSystem.ext | Mathlib.LinearAlgebra.RootSystem.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] [Finite ι] [CharZero R] [IsDomain R]
[Module.IsTorsionFree R M] {P₁ P₂ : RootPairing ι R M N} [P₁.IsRootSystem] [P₂.IsRootSystem],
P₁.to... | true |
Lean.IR.IRType.match_on_same_ctor._@.Lean.Compiler.IR.Basic.840659257._hygCtx._hyg.60 | Lean.Compiler.IR.Basic | {motive : (t t_1 : Lean.IR.IRType) → t.ctorIdx = t_1.ctorIdx → Sort u} →
(t t_1 : Lean.IR.IRType) →
(h : t.ctorIdx = t_1.ctorIdx) →
(Unit → motive Lean.IR.IRType.float Lean.IR.IRType.float ⋯) →
(Unit → motive Lean.IR.IRType.uint8 Lean.IR.IRType.uint8 ⋯) →
(Unit → motive Lean.IR.IRType.uint... | false |
CategoryTheory.Limits.PreservesPullback.iso_hom_fst | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | true |
Lean.Meta.withLetDecl | Lean.Meta.Basic | {n : Type → Type u_1} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
{α : Type} →
Lean.Name →
Lean.Expr →
Lean.Expr →
(Lean.Expr → n α) → optParam Bool false → optParam Lean.LocalDeclKind Lean.LocalDeclKind.default → n α | true |
InnerProductGeometry.cos_angle | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
Real.cos (InnerProductGeometry.angle x y) = inner ℝ x y / (‖x‖ * ‖y‖) | true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.ofDigits_lt_base_pow_length'._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True | false |
Lean.Meta.KExprMap.rec | Lean.Meta.KExprMap | {α : Type} →
{motive : Lean.Meta.KExprMap α → Sort u} →
((map : Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)) → motive { map := map }) →
(t : Lean.Meta.KExprMap α) → motive t | false |
WithBot.giUnbotDBot | Mathlib.Order.GaloisConnection.Basic | {α : Type u} → [inst : Preorder α] → [inst_1 : OrderBot α] → GaloisInsertion (WithBot.unbotD ⊥) WithBot.some | true |
Submodule.orderIsoMapComap_apply' | Mathlib.Algebra.Module.Submodule.Map | ∀ {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₂}
{τ₂₁ : R₂ →+* R} [inst_6 : RingHomInvPair τ₁₂ τ₂₁] [inst_7 : RingHomInvPair τ₂₁ τ₁₂] (e : M... | true |
_private.Lean.Compiler.IR.ElimDeadVars.0.Lean.IR.reshapeWithoutDead.reshape.match_1 | Lean.Compiler.IR.ElimDeadVars | (motive : Lean.IR.FnBody → Sort u_1) →
(curr : Lean.IR.FnBody) →
((x : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (e : Lean.IR.Expr) → (b : Lean.IR.FnBody) → motive (Lean.IR.FnBody.vdecl x ty e b)) →
((j : Lean.IR.JoinPointId) →
(xs : Array Lean.IR.Param) → (v b : Lean.IR.FnBody) → motive (L... | false |
Lean.ImportM.Context.noConfusionType | Lean.Environment | Sort u → Lean.ImportM.Context → Lean.ImportM.Context → Sort u | false |
DFinsupp.linearEquivFunOnFintype | Mathlib.LinearAlgebra.DFinsupp | {ι : Type u_1} →
{R : Type u_3} →
{M : ι → Type u_5} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M i)] →
[inst_2 : (i : ι) → Module R (M i)] → [Fintype ι] → (Π₀ (i : ι), M i) ≃ₗ[R] (i : ι) → M i | true |
IsStronglyCoatomic.of_wellFounded_gt | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α], (WellFounded fun x1 x2 => x1 > x2) → IsStronglyCoatomic α | true |
aestronglyMeasurable_iff_aemeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : MeasurableSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [BorelSpace β]
[SecondCountableTopology β], MeasureTheory.AEStronglyMeasurable f μ ↔ AEMeasurable f μ | true |
IsUnit.finset | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {a : α}, IsUnit a → IsUnit {a} | true |
contDiffWithinAt_const | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E}
{n : WithTop ℕ∞} {c : F}, ContDiffWithinAt 𝕜 n (fun x => c) s x | true |
Nat.cast_succ | Mathlib.Data.Nat.Cast.Defs | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] (n : ℕ), ↑n.succ = ↑n + 1 | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.mkCoe.match_1 | Lean.Elab.Term.TermElabM | (motive : Lean.LOption (Lean.Expr × List Lean.Name) → Sort u_1) →
(__do_lift : Lean.LOption (Lean.Expr × List Lean.Name)) →
((eNew : Lean.Expr) → (expandedCoeDecls : List Lean.Name) → motive (Lean.LOption.some (eNew, expandedCoeDecls))) →
(Unit → motive Lean.LOption.none) → (Unit → motive Lean.LOption.undef... | false |
List.decidableSortedGE | Mathlib.Data.List.Sort | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → DecidablePred List.SortedGE | true |
SimpleGraph._aux_Mathlib_Combinatorics_SimpleGraph_Copy___unexpand_SimpleGraph_IsIndContained_1 | Mathlib.Combinatorics.SimpleGraph.Copy | Lean.PrettyPrinter.Unexpander | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.mem_of_mem_insertMany_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
apply_wcovBy_apply_iff._simp_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {a b : α} {E : Type u_3}
[inst_2 : EquivLike E α β] [OrderIsoClass E α β] (e : E), (e a ⩿ e b) = (a ⩿ b) | false |
LSeries.term_sum_apply | Mathlib.NumberTheory.LSeries.Linearity | ∀ {ι : Type u_1} (f : ι → ℕ → ℂ) (S : Finset ι) (s : ℂ) (n : ℕ),
LSeries.term (∑ i ∈ S, f i) s n = ∑ i ∈ S, LSeries.term (f i) s n | true |
Std.TreeMap.contains_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {k : α}, ∅.contains k = false | true |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.insertMany._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} {ρ : Type u_3} [inst : ForIn Id ρ (α × β)]
(m : Std.DHashMap α fun x => β) (l : ρ), (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany ⟨m.inner, ⋯⟩ l)).WF | false |
Topology.WithLowerSet.toLowerSet_symm | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1}, Topology.WithLowerSet.toLowerSet.symm = Topology.WithLowerSet.ofLowerSet | true |
NonUnitalSubalgebra.iSupLift._proof_4 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] {ι : Sort u_3} [Nonempty ι]
(K : ι → NonUnitalSubalgebra R A), Directed (fun x1 x2 => x1 ≤ x2) K → ↑(iSup K) ⊆ ⋃ i, ↑(K i) | false |
curveIntegralFun_symm | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} (ω : E → E →L[𝕜] F)
(γ : Path a b), curveIntegralFun ω γ.symm = fun x => (-curveIntegralFun ω γ) (1 - x) | true |
Nat.mul_ne_mul_left | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, a ≠ 0 → (b * a ≠ c * a ↔ b ≠ c) | true |
GradedRingHom.map_one | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_6} {τ : Type u_7} [inst : Semiring A] [inst_1 : Semiring B]
[inst_2 : SetLike σ A] [inst_3 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} (f : 𝒜 →+*ᵍ ℬ), f 1 = 1 | true |
CategoryTheory.Bicategory.Adj.forget₁._proof_7 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : CategoryTheory.Bicategory.Adj B} {f g : a ⟶ b}
(η : f ⟶ g) (h : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η h).τl =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl (CategoryTheory.CategoryStruct.comp f h).l).hom
(CategoryTheo... | false |
OpenPartialHomeomorph.extend_image_nhds_mem_nhds_of_boundaryless | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} [I.Boundaryless] {x : M},
x ∈ f.s... | true |
Lean.Meta.Grind.EMatchTheoremKind.leftRight.sizeOf_spec | Lean.Meta.Tactic.Grind.Extension | sizeOf Lean.Meta.Grind.EMatchTheoremKind.leftRight = 1 | true |
FiniteDimensional.basisSingleton._proof_5 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], StrongRankCondition K | false |
MulAction.is_one_pretransitive_iff | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α],
MulAction.IsMultiplyPretransitive G α 1 ↔ MulAction.IsPretransitive G α | true |
ContinuousMap.inv_apply | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Inv β]
[inst_3 : ContinuousInv β] (f : C(α, β)) (x : α), f⁻¹ x = (f x)⁻¹ | true |
Std.Time.Database.TZdb.inst.match_4 | Std.Time.Zoned.Database.TZdb | (motive : Option Std.Time.TimeZone.ZoneRules → Sort u_1) →
(x : Option Std.Time.TimeZone.ZoneRules) →
(Unit → motive none) → ((a : Std.Time.TimeZone.ZoneRules) → motive (some a)) → motive x | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.take_set_of_le._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {i j : ℕ}, j ≤ i → ∀ i_1 < j, i = i_1 → False | false |
Lists.Subset.decidable.match_1 | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : Lists' α true → Lists' α true → Sort u_2) →
(x x_1 : Lists' α true) →
((x : Lists' α true) → motive Lists'.nil x) →
((b : Bool) → (a : Lists' α b) → (l₁ l₂ : Lists' α true) → motive (a.cons' l₁) l₂) → motive x x_1 | false |
Unique.rec | Mathlib.Logic.Unique | {α : Sort u} →
{motive : Unique α → Sort u_1} →
((toInhabited : Inhabited α) →
(uniq : ∀ (a : α), a = default) → motive { toInhabited := toInhabited, uniq := uniq }) →
(t : Unique α) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.