name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
FreeAddMagma.liftAux | Mathlib.Algebra.Free | {α : Type u} → {β : Type v} → [Add β] → (α → β) → FreeAddMagma α → β | true |
FirstOrder.Language.graphRel.adj.sizeOf_spec | Mathlib.ModelTheory.Graph | sizeOf FirstOrder.Language.graphRel.adj = 1 | true |
CommMonCat.FilteredColimits.colimitCommMonoid._proof_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] [inst_1 : CategoryTheory.IsFiltered J]
(F : CategoryTheory.Functor J CommMonCat) (x y : ↑(CommMonCat.FilteredColimits.M F)), x * y = y * x | false |
Std.DHashMap.Raw.Const.get?_erase_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α}, Std.DHashMap.Raw.Const.get? (m.erase k) k = none | true |
Antitone.image_upperBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone f → ∀ {s : Set α}, f '' upperBounds s ⊆ lowerBounds (f '' s) | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Icc_diff_Ioc_self._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
FirstOrder.Language.BoundedFormula.realize_sup._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ ⊔ ψ).Realize v xs = (φ.Realize v xs ∨ ψ.Realize v xs) | false |
Turing.TM0.Cfg.noConfusionType | Mathlib.Computability.TuringMachine.PostTuringMachine | Sort u →
{Γ : Type u_1} →
{Λ : Type u_2} →
[inst : Inhabited Γ] →
Turing.TM0.Cfg Γ Λ → {Γ' : Type u_1} → {Λ' : Type u_2} → [inst' : Inhabited Γ'] → Turing.TM0.Cfg Γ' Λ' → Sort u | false |
_private.Init.Data.Slice.List.Lemmas.0.ListSlice.size_mkSlice_ric._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {γ : Type u} {α β : Type v} [inst : Std.ToIterator (Std.Slice γ) Id α β] [inst_1 : Std.Iterator α Id β]
{s : Std.Slice γ} [inst_2 : Std.Slice.SliceSize γ] [Std.Slice.LawfulSliceSize γ] [Std.Iterators.Finite α Id],
s.size = s.toList.length | false |
TopologicalSpace.CompactOpens.instBooleanAlgebra | Mathlib.Topology.Sets.Compacts | {α : Type u_1} →
[inst : TopologicalSpace α] → [CompactSpace α] → [T2Space α] → BooleanAlgebra (TopologicalSpace.CompactOpens α) | true |
AddHom.srange._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] (f : M →ₙ+ N), Set.range ⇑f = ⇑f '' Set.univ | false |
HasStrictFDerivAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{f' g' : E →L[𝕜] F} {x : E},
HasStrictFDerivAt f f' x → HasStrictFDerivAt g g' x → HasStrictFDe... | true |
IsUnifLocDoublingMeasure.doublingConstant.congr_simp | Mathlib.MeasureTheory.Constructions.Pi | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] (μ μ_1 : MeasureTheory.Measure α)
(e_μ : μ = μ_1) [inst_2 : IsUnifLocDoublingMeasure μ],
IsUnifLocDoublingMeasure.doublingConstant μ = IsUnifLocDoublingMeasure.doublingConstant μ_1 | true |
Std.Time.Formats.leanDateTime24Hour | Std.Time.Format | Std.Time.GenericFormat (Std.Time.Awareness.only Std.Time.TimeZone.GMT) | true |
IsInvariantSubring.toMulSemiringAction._proof_5 | Mathlib.Algebra.Ring.Action.Invariant | ∀ (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[inst_3 : IsInvariantSubring M S] (m : M) (s₁ s₂ : ↥S), m • (s₁ + s₂) = m • s₁ + m • s₂ | false |
Polynomial.fiberEquivQuotient._proof_13 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(f : Polynomial R →ₐ[R] S) (p : Ideal R) [inst_3 : p.IsPrime],
RingHom.ker ↑f ≤
RingHom.ker
((Ideal.Quotient.mkₐ R (Ideal.map (Polynomial.mapRingHom (algebraMap R p.ResidueField)) (RingHom.ker ↑f))).comp
... | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt | Mathlib.Tactic.Translate.UnfoldBoundary | Type | true |
Set.decidableSingleton | Mathlib.Data.Set.Insert | {α : Type u_1} → (a b : α) → [Decidable (a = b)] → Decidable (a ∈ {b}) | true |
ContinuousMap.HomotopyWith.symm_symm | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {P : C(X, Y) → Prop}
{f₀ f₁ : C(X, Y)} (F : f₀.HomotopyWith f₁ P), F.symm.symm = F | true |
IO.FS.Metadata.type | Init.System.IO | IO.FS.Metadata → IO.FS.FileType | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.rotate_neg_eq_intMinSealed_sub | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n : ℕ} {x : BitVec n}, BitVec.Signed.rotate✝ (-x) = BitVec.Signed.intMinSealed✝ n - x | true |
_private.Mathlib.Analysis.Convex.Combination.0.Finset.centerMass_segment._simp_1_1 | Mathlib.Analysis.Convex.Combination | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, a * f i = a * ∑ i ∈ s, f i | false |
FractionalIdeal.count_mul | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R)
{I I' : FractionalIdeal (nonZeroDivisors R) K},
I ≠ 0 → I' ≠ 0 → FractionalIdeal.count K v (I * I') = FractionalIdeal... | true |
Aesop.RuleTacDescr.tacGen.injEq | Aesop.RuleTac.Descr | ∀ (decl decl_1 : Lean.Name), (Aesop.RuleTacDescr.tacGen decl = Aesop.RuleTacDescr.tacGen decl_1) = (decl = decl_1) | true |
directedOn_le_Ioc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), DirectedOn (fun x1 x2 => x1 ≤ x2) (Set.Ioc a b) | true |
_private.Mathlib.Data.Fintype.Perm.0.mem_of_mem_permsOfList.match_1_3 | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l : List α) (f : Equiv.Perm α)
(motive : (∃ a_1 ∈ l, f ∈ List.map (fun f => Equiv.swap a a_1 * f) (permsOfList l)) → Prop)
(x : ∃ a_1 ∈ l, f ∈ List.map (fun f => Equiv.swap a a_1 * f) (permsOfList l)),
(∀ (y : α) (hy : y ∈ l) (hy' : f ∈ List.map (fun f => Equiv.swa... | false |
Lean.Server.Test.Runner.Client.InteractiveGoalCore.normalize | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.InteractiveGoalCore →
Lean.Server.Test.Runner.Client.NormalizeM Lean.Server.Test.Runner.Client.InteractiveGoalCore | true |
mabs_eq_self._simp_2 | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a : G}, (|a|ₘ = a) = (1 ≤ a) | false |
instNegFloat | Init.Data.Float | Neg Float | true |
Int.neg_lt_zero_iff._simp_1 | Init.Data.Int.Order | ∀ {a : ℤ}, (-a < 0) = (0 < a) | false |
_private.Mathlib.Analysis.Normed.Group.Uniform.0.antilipschitzWith_iff_exists_mul_le_norm.match_1_3 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {𝓕 : Type u_3} {E : Type u_1} {F : Type u_2} [inst : SeminormedAddGroup E] [inst_1 : SeminormedAddGroup F]
[inst_2 : FunLike 𝓕 E F] {f : 𝓕} (motive : (∃ c > 0, ∀ (x : E), c * ‖x‖ ≤ ‖f x‖) → Prop)
(x : ∃ c > 0, ∀ (x : E), c * ‖x‖ ≤ ‖f x‖),
(∀ (c : ℝ) (hc0 : c > 0) (hc : ∀ (x : E), c * ‖x‖ ≤ ‖f x‖), motive ⋯) ... | false |
Set.eq_mem_setOf | Mathlib.Data.Set.Operations | ∀ {α : Type u} (p : α → Prop), p = fun x => x ∈ {a | p a} | true |
ArchimedeanClass.toAddSubgroup_ball | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M] (c : ArchimedeanClass M), (ArchimedeanClass.ball K c).toAdd... | true |
Lean.RArray.getImpl.eq_1 | Init.Data.RArray | ∀ {α : Type u} (n : ℕ) (x : α), (Lean.RArray.leaf x).getImpl n = x | true |
Std.Time.Number.mk | Std.Time.Format.Basic | ℕ → Std.Time.Number | true |
CategoryTheory.MorphismProperty.Over.mapId._auto_1 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | Lean.Syntax | false |
CategoryTheory.SplitEpi.op._proof_2 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y} (h : CategoryTheory.SplitEpi f),
CategoryTheory.CategoryStruct.comp f.op h.section_.op = CategoryTheory.CategoryStruct.id (Opposite.op Y) | false |
WeierstrassCurve.isCharTwoJNeZeroNF_iff | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R), W.IsCharTwoJNeZeroNF ↔ W.a₁ = 1 ∧ W.a₃ = 0 ∧ W.a₄ = 0 | true |
Metric.hausdorffDist_empty' | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set α}, Metric.hausdorffDist ∅ s = 0 | true |
continuousAt_const_vadd_iff | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {β : Type u_3} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : AddGroup G]
[inst_2 : AddAction G α] [ContinuousConstVAdd G α] [inst_4 : TopologicalSpace β] {f : β → α} {b : β} (c : G),
ContinuousAt (fun x => c +ᵥ f x) b ↔ ContinuousAt f b | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkCasesAndThen | Lean.Meta.Tactic.Grind.Split | Lean.TSyntax `grind → List (Lean.TSyntax `grind) → Lean.CoreM (Lean.TSyntax `grind) | true |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.factorial_mul_ascFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | false |
ISize.lt_trans | Init.Data.SInt.Lemmas | ∀ {a b c : ISize}, a < b → b < c → a < c | true |
Lean.Elab.CompletionInfo.errorName.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (stx partialId : Lean.Syntax),
sizeOf (Lean.Elab.CompletionInfo.errorName stx partialId) = 1 + sizeOf stx + sizeOf partialId | true |
CategoryTheory.MorphismProperty.colimitsOfShape_monotone | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W₁ W₂ : CategoryTheory.MorphismProperty C},
W₁ ≤ W₂ →
∀ (J : Type u_2) [inst_1 : CategoryTheory.Category.{v_2, u_2} J], W₁.colimitsOfShape J ≤ W₂.colimitsOfShape J | true |
Std.ExtTreeSet.mem_diff_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
k ∈ t₁ \ t₂ ↔ k ∈ t₁ ∧ k ∉ t₂ | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.IsBasis.map._simp_1_4 | Mathlib.Combinatorics.Matroid.Map | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | false |
AbsoluteValue.IsEuclidean | Mathlib.Algebra.Order.AbsoluteValue.Euclidean | {R : Type u_1} →
{S : Type u_2} →
[inst : EuclideanDomain R] → [inst_1 : Semiring S] → [inst_2 : PartialOrder S] → AbsoluteValue R S → Prop | true |
Std.Iter.step_filterMapM.match_1 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | {β : Type u_1} →
{n : Type u_1 → Type u_2} →
{β' : Type u_1} →
{f : β → n (Option β')} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((... | false |
MonadWithReader.mk.noConfusion | Init.Prelude | {ρ : outParam (Type u)} →
{m : Type u → Type v} →
{P : Sort u_1} →
{withReader withReader' : {α : Type u} → (ρ → ρ) → m α → m α} →
{ withReader := withReader } = { withReader := withReader' } → (withReader ≍ withReader' → P) → P | false |
Polynomial.Bivariate.«_aux_Mathlib_Algebra_Polynomial_Bivariate___delab_app_Polynomial_Bivariate_term_[X][Y]_1» | Mathlib.Algebra.Polynomial.Bivariate | Lean.PrettyPrinter.Delaborator.Delab | false |
ContMDiff.mul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] {E' :... | true |
NonemptyInterval.inv_mem_inv | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : CommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedMonoid α] (s : NonemptyInterval α),
∀ a ∈ s, a⁻¹ ∈ s⁻¹ | true |
CStarAlgebra.isUnit_of_le._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
SetSemiring.instCompleteBooleanAlgebra._aux_21 | Mathlib.Data.Set.Semiring | {α : Type u_1} → SetSemiring α → SetSemiring α | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_11 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Std.DTreeMap.Internal.Impl.Equiv.rfl | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t : Std.DTreeMap.Internal.Impl α β}, t.Equiv t | true |
vecMulVecBilin._proof_9 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_1} {n : Type u_2} (R : Type u_5) (S : Type u_4) {A : Type u_3} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [inst_4 : Module S A] [inst_5 : SMulCommClass S R A]
[inst_6 : SMulCommClass S A A] [IsScalarTower R A A] (x : R) (x_1 : m → A),
{ toF... | false |
Filter.HasBasis.principal_inf | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ∀ (s' : Set α), (Filter.principal s' ⊓ l).HasBasis p fun i => s' ∩ s i | true |
MvPolynomial.IsWeightedHomogeneous.sum_weight_X_mul_pderiv | Mathlib.RingTheory.MvPolynomial.EulerIdentity | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] {φ : MvPolynomial σ R} [inst_1 : Fintype σ] {n : ℕ} {w : σ → ℕ},
MvPolynomial.IsWeightedHomogeneous w φ n → ∑ i, w i • (MvPolynomial.X i * (MvPolynomial.pderiv i) φ) = n • φ | true |
ProbabilityTheory.IndepFun.mgf_add | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ} {X Y : Ω → ℝ},
ProbabilityTheory.IndepFun X Y μ →
MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * X ω)) μ →
MeasureTheory.AEStronglyMeasurable (fun ω => Real.exp (t * Y ω)) μ →
ProbabilityTheory.mgf (X + Y) μ t... | true |
CategoryTheory.Limits.ChosenPullback.mk.injEq | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} (pullback : C)
(p₁ : pullback ⟶ X₁) (p₂ : pullback ⟶ X₂)
(condition : CategoryTheory.CategoryStruct.comp p₁ f₁ = CategoryTheory.CategoryStruct.comp p₂ f₂)
(isLimit : CategoryTheory.Limits.IsLimit (CategoryTheory.Lim... | true |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.matchArgs? | Lean.Meta.Tactic.Grind.EMatch | Lean.Meta.Grind.EMatch.Choice → Lean.Expr → Lean.Expr → OptionT Lean.Meta.Grind.GoalM Lean.Meta.Grind.EMatch.Choice | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop.match_1.eq_2 | Init.Data.Nat.Fold | ∀ {α : Type u_2} (n : ℕ) (motive : (x : ℕ) → x ≤ n → α → Sort u_1) (m : ℕ) (h : m.succ ≤ n) (a : α)
(h_1 : (h : 0 ≤ n) → (a : α) → motive 0 h a) (h_2 : (m : ℕ) → (h : m.succ ≤ n) → (a : α) → motive m.succ h a),
(match m.succ, h, a with
| 0, h, a => h_1 h a
| m.succ, h, a => h_2 m h a) =
h_2 m h a | true |
Lean.Meta.Tactic.Cbv.CbvSimprocDeclExtState.newEntries._default | Lean.Meta.Tactic.Cbv.CbvSimproc | Lean.PersistentHashMap Lean.Name (Array Lean.Meta.DiscrTree.Key) | false |
CategoryTheory.Functor.IsFinitelyAccessible_iff_preservesFilteredColimitsOfSize | Mathlib.CategoryTheory.Presentable.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F : CategoryTheory.Functor C D},
F.IsFinitelyAccessible ↔ CategoryTheory.Limits.PreservesFilteredColimitsOfSize.{w, w, v, v', u, u'} F | true |
QuadraticForm.dualProdProdIsometry_invFun | Mathlib.LinearAlgebra.QuadraticForm.Dual | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N]
(a : (Module.Dual R M × M) × Module.Dual R N × N),
QuadraticForm.dualProdProdIsometry.invFun a =
((Module.dualProdDualEquivDual R M N).symm.p... | true |
OpenPartialHomeomorph.MDifferentiable.range_mfderiv_eq_top | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : 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 : NormedAddComm... | true |
LinearMap.separatingLeft_toMatrix₂_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {n : Type u_11} {m : Type u_12} [inst : CommRing R]
[inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq n] [inst_4 : Fintype n]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M₂]
(b₁ : Module.Basis ... | false |
Rep.indToCoind_coindToInd | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] (A : Rep.{w, u, v} k ↥S) [inst_3 : S.FiniteIndex],
A.coindToInd ∘ₗ A.indToCoind = LinearMap.id | true |
Filter.Tendsto.ofReal | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_2} {l : Filter α} {f : α → ℝ} {x : ℝ},
Filter.Tendsto f l (nhds x) → Filter.Tendsto (fun x => ↑(f x)) l (nhds ↑x) | true |
DirectSum.lieModuleOf._proof_2 | Mathlib.Algebra.Lie.DirectSum | ∀ (R : Type u_3) (ι : Type u_1) [inst : CommRing R] (L : Type u_4) (M : ι → Type u_2) [inst_1 : LieRing L]
[inst_2 : (i : ι) → AddCommGroup (M i)] [inst_3 : (i : ι) → Module R (M i)] [inst_4 : (i : ι) → LieRingModule L (M i)]
[inst_5 : DecidableEq ι] (j : ι) {x : L} {m : M j},
(DirectSum.lof R ι M j).toFun ⁅x, m⁆... | false |
_aux_Mathlib_Topology_Order_Hom_Basic___unexpand_ContinuousOrderHom_1 | Mathlib.Topology.Order.Hom.Basic | Lean.PrettyPrinter.Unexpander | false |
IO.FS.createDirAll._unsafe_rec | Init.System.IO | System.FilePath → IO Unit | false |
NonUnitalStarAlgebra.gi._proof_3 | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (x : Set A) (x_1 : ↑(NonUnitalStarAlgebra.adjoin R x) ≤ x),
(NonUnitalSta... | false |
Ideal.mapCotangent._proof_1 | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_3} [inst : CommRing R] {A : Type u_1} {B : Type u_2} [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | false |
ContinuousLinearMap.exist_extension_of_finiteDimensional_range | Mathlib.Analysis.Normed.Module.HahnBanach | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜] {E : Type u_2} {F : Type u_3}
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] {p : Submodule 𝕜 E} (f : ↥p →L[𝕜] F) [FiniteDimensional 𝕜 ↥(↑f).range],
∃ g, f... | true |
Module.Grassmannian.ext | Mathlib.RingTheory.Grassmannian | ∀ {R : Type u} [inst : CommRing R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {k : ℕ}
{N₁ N₂ : Module.Grassmannian R M k}, N₁.toSubmodule = N₂.toSubmodule → N₁ = N₂ | true |
LinearMap.tensorProduct._proof_4 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_3) (A : Type u_1) (N : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass A A (TensorProduct R A N) | false |
Batteries.BinaryHeap._sizeOf_inst | Batteries.Data.BinaryHeap.Basic | (α : Type u_1) → (lt : α → α → Bool) → [SizeOf α] → SizeOf (Batteries.BinaryHeap α lt) | false |
Equiv.swap_smul_self_smul | Mathlib.GroupTheory.Perm.Basic | ∀ {α : Type u} {β : Type v} [inst : DecidableEq α] [inst_1 : MulAction (Equiv.Perm α) β] (i j : α) (x : β),
Equiv.swap i j • Equiv.swap i j • x = x | true |
_private.Init.Data.Int.Linear.0.Int.Linear.instBEqPoly.beq.match_1.splitter._sparseCasesOn_3 | Init.Data.Int.Linear | {motive : Int.Linear.Poly → Sort u} →
(t : Int.Linear.Poly) → ((k : ℤ) → motive (Int.Linear.Poly.num k)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
PosNum.divMod_to_nat | Mathlib.Data.Num.ZNum | ∀ (d n : PosNum), ↑n / ↑d = ↑(d.divMod n).1 ∧ ↑n % ↑d = ↑(d.divMod n).2 | true |
ENNReal.HolderConjugate.instOneInfty | Mathlib.Data.ENNReal.Holder | ENNReal.HolderConjugate 1 ⊤ | true |
ComplexShape.Embedding.instIsTruncLEOpOfIsTruncGE | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsTruncGE],
e.op.IsTruncLE | true |
_private.Mathlib.NumberTheory.Height.Projectivization.0.Projectivization.mulHeight_aux | Mathlib.NumberTheory.Height.Projectivization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [Finite ι]
(a b : { v // v ≠ 0 }) (t : K), ↑a = t • ↑b → Height.mulHeight ↑a = Height.mulHeight ↑b | true |
smoothSheafCommRing.nonunits_stalk | Mathlib.Geometry.Manifold.Sheaf.LocallyRingedSpace | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {EM : Type u_1} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_2} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{M : Type u} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace HM M] (x : M),
nonunits ↑((smoothSheaf... | true |
Pi.seminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Constructions | {ι : Type u_1} →
{G : ι → Type u_4} → [Fintype ι] → [(i : ι) → SeminormedAddCommGroup (G i)] → SeminormedAddCommGroup ((i : ι) → G i) | true |
Algebra.Extension.cotangentEquiv._proof_5 | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u_3} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S),
Function.Injective ⇑(LinearMap.liftBaseChange S Algebra.Extension.Cotangent.mk) ∧
Function.Surjective ⇑(LinearMap.liftBaseChange S Algebra.Extension.Cotangent.mk) | false |
Sat.Clause.reify.prop | Mathlib.Tactic.Sat.FromLRAT | ∀ {v : Sat.Valuation} {c : Sat.Clause} {p : Prop}, Sat.Clause.reify v c p → ¬v.satisfies c → p | true |
frobenius_apply_frobeniusEquiv_symm | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p] (x : R),
(frobenius R p) ((frobeniusEquiv R p).symm x) = x | true |
_private.Mathlib.Data.Part.0.Part.get_eq_iff_mem.match_1_1 | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α} (motive : a ∈ o → Prop) (x : a ∈ o),
(∀ (w : o.Dom) (H : o.get w = a), motive ⋯) → motive x | false |
DifferentiableAt.hasGradientAt | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x : F}, DifferentiableAt 𝕜 f x → HasGradientAt f (gradient f x) x | true |
AddOpposite.instIsCancelAdd | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] [IsCancelAdd α], IsCancelAdd αᵃᵒᵖ | true |
Lean.Elab.instInhabitedCommandInfo | Lean.Elab.InfoTree.Types | Inhabited Lean.Elab.CommandInfo | true |
Std.ExtDHashMap.Const.get_union_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁.union m₂},
Std.ExtDHashMap.Const.get (m₁.union m₂) k h' = Std.ExtDHashMap.Const.get m₂ k ⋯ | true |
GaussianFourier.integrable_cexp_neg_sum_mul_add | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ {ι : Type u_2} [inst : Fintype ι] {b : ι → ℂ},
(∀ (i : ι), 0 < (b i).re) →
∀ (c : ι → ℂ),
MeasureTheory.Integrable (fun v => Complex.exp (-∑ i, b i * ↑(v i) ^ 2 + ∑ i, c i * ↑(v i))) MeasureTheory.volume | true |
Zsqrtd.instStar | Mathlib.NumberTheory.Zsqrtd.Basic | {d : ℤ} → Star (ℤ√d) | true |
Batteries.CodeAction.patternFromConstructor.match_1 | Batteries.CodeAction.Match | (motive : Lean.Name → Sort u_1) →
(ctor : Lean.Name) →
(Unit → motive `Nat.zero) →
(Unit → motive `Nat.succ) →
(Unit → motive `List.nil) →
(Unit → motive `List.cons) →
(Unit → motive `Option.some) →
(Unit → motive `Option.none) →
(Unit → motive `Bo... | false |
Qq.QuotedDefEq.recOn | Qq.Typ | {u : Lean.Level} →
{α : Q(Sort u)} →
{lhs rhs : Q(«$α»)} → {motive : «$lhs» =Q «$rhs» → Sort u} → (t : «$lhs» =Q «$rhs») → motive ⋯ → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.