name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.FunctorToTypes.monoFactorisation_e | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Images | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor C (Type u)} (f : F ⟶ G),
(CategoryTheory.FunctorToTypes.monoFactorisation f).e = CategoryTheory.Subfunctor.toRange f | true |
Std.HashMap.Raw.all_eq_false_iff_exists_mem_getElem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = false) | true |
Lean.IR.SimpleGroundArg.reference.noConfusion | Lean.Compiler.IR.SimpleGroundExpr | {P : Sort u} →
{n n' : Lean.Name} → Lean.IR.SimpleGroundArg.reference n = Lean.IR.SimpleGroundArg.reference n' → (n = n' → P) → P | false |
Array.partition | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α × Array α | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_6 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {W X Y Z : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom W X)
(g : CategoryTheory.Lax.LaxTrans.Hom X Y) (h : CategoryTheory.Lax.LaxTrans.Hom Y Z),
{ as := { as := f.as.vcomp g.as }.as.vcomp h.as } = { as := f.as.vcomp { as := g.as.vcomp h.as }.as } | false |
isAddRightRegular_ofColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : Colex α}, IsAddRightRegular (ofColex a) ↔ IsAddRightRegular a | true |
_private.Mathlib.RingTheory.Ideal.Quotient.PowTransition.0.Submodule.powSMulQuotInclusion_injective._simp_1_3 | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {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₂}
[inst_6 : RingHomSurjective σ₁₂] {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R M} {q : Submodule R₂ M₂},
(Submodule.map f p ≤ q) = (p ≤ Submodule.comap f q) | false |
StrongFEPair.symm_Λ_eq | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : StrongFEPair E), P.symm.Λ = mellin P.g | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.r_pos._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), (0 < z.im) = True | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.Defs.0.ArithmeticFunction.IsMultiplicative.mul._simp_1_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {n : ℕ} {x : ℕ × ℕ}, (x ∈ n.divisorsAntidiagonal) = (x.1 * x.2 = n ∧ n ≠ 0) | false |
CategoryTheory.Endofunctor.Algebra.functorOfNatTrans | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor C C} →
(G ⟶ F) → CategoryTheory.Functor (CategoryTheory.Endofunctor.Algebra F) (CategoryTheory.Endofunctor.Algebra G) | true |
exists_continuous_add_one_of_isCompact_nnreal | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {s₀ s₁ t : Set X},
IsCompact s₀ →
IsCompact s₁ →
IsCompact t →
Disjoint s₀ s₁ → s₀ ∪ s₁ ⊆ t → ∃ f₀ f₁, Set.EqOn (⇑f₀) 1 s₀ ∧ Set.EqOn (⇑f₁) 1 s₁ ∧ Set.EqOn (⇑(f₀ + f₁)) 1 t | true |
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{combined : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget aig combined →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 : DecidableEq α'] →
{aig' : Std.Sat.AIG α'} →
{combined' : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget aig' combined' → Sort u | false |
Lie.Derivation.ofLieDerivation | Mathlib.Algebra.Lie.Derivation.BaseChange | {R : Type u_1} →
[inst : CommRing R] →
(A : Type u_2) →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
LieDerivation R L L →ₗ⁅R⁆ LieDerivation R (TensorProduct R A L) (TensorProduct R A L) | true |
AddGroupNorm.casesOn | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupNorm G → Sort u} →
(t : AddGroupNorm G) →
((toAddGroupSeminorm : AddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toAddGroupSeminorm.toFun x = 0 → x = 0) →
motive { toAddGroupSeminorm := toAddGroupSeminorm, eq_zero_of_map_eq_zero' := eq_zero_of_map_eq_zero' }) →
motive t | false |
Std.DTreeMap.Internal.Impl.glue.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl_2 : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) (sz' : ℕ) (k'_1 : α) (v'_1 : β k'_1)
(l'' r'' : Std.DTreeMap.Internal.Impl α β) (hr_2 : (Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r'').Balanced)
(hlr_3 :
Std.DTreeMap.Internal.Impl.BalancedAtRoot (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size
(Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r'').size),
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').glue (Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r'') hl_2
hr_2 hlr_3 =
if size < sz' then
match Std.DTreeMap.Internal.Impl.minView k'_1 v'_1 l'' r'' ⋯ ⋯ ⋯ with
| { k := dk, v := dv, tree := { impl := dt, balanced_impl := hdt, size_impl := hdt' } } =>
Std.DTreeMap.Internal.Impl.balanceLErase dk dv (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') dt hl_2 ⋯ ⋯
else
match Std.DTreeMap.Internal.Impl.maxView k' v' l' r' ⋯ ⋯ ⋯ with
| { k := dk, v := dv, tree := { impl := dt, balanced_impl := hdt, size_impl := hdt' } } =>
Std.DTreeMap.Internal.Impl.balanceRErase dk dv dt (Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r'') ⋯
hr_2 ⋯ | true |
OpenPartialHomeomorph.IsImage.restr._proof_3 | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y} (h : e.IsImage s t), ContinuousOn ↑e.symm ⋯.restr.target | false |
_private.Mathlib.MeasureTheory.Measure.Stieltjes.0.StieltjesFunction.outer_trim._simp_1_1 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a | false |
Lean.Lsp.instToJsonDiagnosticSeverity.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Lsp.DiagnosticSeverity → Sort u_1) →
(x : Lean.Lsp.DiagnosticSeverity) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.error) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.warning) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.information) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.hint) → motive x | false |
Vector.range'._proof_1 | Init.Data.Vector.Basic | ∀ (start size step : ℕ), (Array.range' start size step).size = size | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.forall_mem_sup._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {N : Type u_4} [inst : CommMonoid N] {s t : Submonoid N} {x : N}, (x ∈ s ⊔ t) = ∃ y ∈ s, ∃ z ∈ t, y * z = x | false |
_private.Mathlib.NumberTheory.LSeries.SumCoeff.0.LSeries_tendsto_sub_mul_nhds_one_of_tendsto_sum_div_aux₂ | Mathlib.NumberTheory.LSeries.SumCoeff | ∀ {l : ℂ} {s T ε : ℝ} {S : ℝ → ℂ},
MeasureTheory.LocallyIntegrableOn (fun t => S t - l * ↑t) (Set.Ici 1) MeasureTheory.volume →
0 < ε →
1 < s →
1 ≤ T → (∀ t ≥ T, ‖S t - l * ↑t‖ ≤ ε * t) → (s - 1) * ∫ (t : ℝ) in Set.Ioi T, ‖S t - l * ↑t‖ * t ^ (-s - 1) ≤ ε | true |
AlgebraicTopology.isZero_singularHomologyFunctor_of_totallyDisconnectedSpace | Mathlib.AlgebraicTopology.SingularHomology.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.CategoryWithHomology C] (n : ℕ) (R : C) (X : TopCat)
[TotallyDisconnectedSpace ↑X],
n ≠ 0 → CategoryTheory.Limits.IsZero (((AlgebraicTopology.singularHomologyFunctor C n).obj R).obj X) | true |
Ideal.fiberIsoOfBijectiveResidueField._proof_6 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R' : Type u_1} [inst : CommRing R'] {q : Ideal R'} [inst_1 : q.IsPrime],
SMulCommClass R' q.ResidueField q.ResidueField | false |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.invtSubmoduleToLieIdeal_top._simp_1_2 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') | false |
Lean.Omega.LinearCombo.coordinate_eval | Init.Omega.LinearCombo | ∀ (i : ℕ) (v : Lean.Omega.Coeffs), (Lean.Omega.LinearCombo.coordinate i).eval v = v.get i | true |
Group.fg_of_mul_group_fg | Mathlib.GroupTheory.Finiteness | ∀ {H : Type u_4} [inst : AddGroup H] [AddGroup.FG H], Group.FG (Multiplicative H) | true |
CategoryTheory.EnrichedFunctor.forgetComp_hom_app | Mathlib.CategoryTheory.Enriched.Basic | ∀ {W : Type v'} [inst : CategoryTheory.Category.{w', v'} W] [inst_1 : CategoryTheory.MonoidalCategory W] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory W C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory W D]
{E : Type u₃} [inst_4 : CategoryTheory.EnrichedCategory W E] (F : CategoryTheory.EnrichedFunctor W C D)
(G : CategoryTheory.EnrichedFunctor W D E) (X : CategoryTheory.ForgetEnrichment W C),
(F.forgetComp G).hom.app X =
CategoryTheory.CategoryStruct.id
(CategoryTheory.ForgetEnrichment.of W (G.obj (F.obj (CategoryTheory.ForgetEnrichment.to W X)))) | true |
NonUnitalSubalgebra.nonUnitalNormedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NonUnitalNormedRing E] [inst_2 : Module 𝕜 E]
(s : NonUnitalSubalgebra 𝕜 E) (x y : ↥s), dist x y = ‖-x + y‖ | false |
ContinuousMulEquiv.trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_1} →
{N : Type u_2} →
[inst : TopologicalSpace M] →
[inst_1 : TopologicalSpace N] →
[inst_2 : Mul M] →
[inst_3 : Mul N] →
{L : Type u_3} → [inst_4 : Mul L] → [inst_5 : TopologicalSpace L] → M ≃ₜ* N → N ≃ₜ* L → M ≃ₜ* L | true |
instDecidableEqChar.match_1 | Init.Prelude | (c d : Char) →
(motive : Decidable (c.val = d.val) → Sort u_1) →
(x : Decidable (c.val = d.val)) →
((h : c.val = d.val) → motive (isTrue h)) → ((h : ¬c.val = d.val) → motive (isFalse h)) → motive x | false |
TrivSqZeroExt.fst_exp | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [Algebra ℚ R] [Module ℚ M]
[inst_4 : Module R M] [inst_5 : Module Rᵐᵒᵖ M] [inst_6 : IsCentralScalar R M] [inst_7 : TopologicalSpace R]
[inst_8 : TopologicalSpace M] [inst_9 : IsTopologicalRing R] [inst_10 : IsTopologicalAddGroup M]
[inst_11 : ContinuousSMul R M] [inst_12 : ContinuousSMul Rᵐᵒᵖ M] [T2Space R] [T2Space M] (x : TrivSqZeroExt R M),
(NormedSpace.exp x).fst = NormedSpace.exp x.fst | true |
List.get._unsafe_rec | Init.Prelude | {α : Type u} → (as : List α) → Fin as.length → α | false |
MeasurableEmbedding.ae_map_iff | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ {p : β → Prop} {μ : MeasureTheory.Measure α},
(∀ᵐ (x : β) ∂MeasureTheory.Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x) | true |
Affine.Triangle.circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{t₁ t₂ : Affine.Triangle ℝ P} {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂ ≠ i₃ →
t₁.points i₁ = t₂.points i₁ →
t₁.points i₃ = t₂.points i₃ →
2 • EuclideanGeometry.oangle (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) =
2 • EuclideanGeometry.oangle (t₂.points i₁) (t₂.points i₂) (t₂.points i₃) →
Affine.Simplex.circumsphere t₁ = Affine.Simplex.circumsphere t₂ | true |
Multiset.decidableMem | Mathlib.Data.Multiset.Defs | {α : Type u_1} → [DecidableEq α] → (a : α) → (s : Multiset α) → Decidable (a ∈ s) | true |
List.Forall.imp | Mathlib.Data.List.Basic | ∀ {α : Type u} {p q : α → Prop}, (∀ (x : α), p x → q x) → ∀ {l : List α}, List.Forall p l → List.Forall q l | true |
cast_inj | Mathlib.Logic.Function.Basic | ∀ {α β : Type u} (h : α = β) {x y : α}, cast h x = cast h y ↔ x = y | true |
Fintype.subtypeEq._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} (y x : α), x ∈ {y} ↔ x = y | false |
Lean.ParserCompiler.instInhabitedCombinatorAttribute.default | Lean.ParserCompiler.Attribute | Lean.ParserCompiler.CombinatorAttribute | true |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.natDegree_comp._simp_1_2 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.leadingCoeff = 0) = (p = 0) | false |
CategoryTheory.WithInitial.map | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
CategoryTheory.Functor C D →
CategoryTheory.Functor (CategoryTheory.WithInitial C) (CategoryTheory.WithInitial D) | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.toList_succ_succ_eq_map._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
_private.Mathlib.MeasureTheory.Measure.MeasuredSets.0.MeasureTheory.exists_measure_symmDiff_lt_of_generateFrom_isSetRing._simp_1_10 | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
Array.instDecidableExistsAndMemOfDecidablePred | Init.Data.Array.Lemmas | {α : Type u_1} → {xs : Array α} → {p : α → Prop} → [DecidablePred p] → Decidable (∃ x ∈ xs, p x) | true |
ContinuousCohomology.Iobj._proof_9 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ {R : Type u_1} {G : Type u_3} [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] (rep : Action (TopModuleCat R) G), ContinuousSMul R C(G, ↑rep.V.toModuleCat) | false |
CategoryTheory.Monad.beckCofork_π | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckCofork X).π = X.a | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.length_nontrivial._simp_1_2 | Mathlib.Data.List.Cycle | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | false |
Subarray | Init.Data.Array.Subarray | Type u → Type u | true |
Associates.coe_unit_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (u : (Associates M)ˣ), ↑u = 1 | true |
Lean.MessageData.Exprs.rec | Mathlib.Lean.MessageData.ForExprs | {motive : Lean.MessageData.Exprs → Sort u} →
((msg : Lean.MessageData) → motive { msg := msg }) → (t : Lean.MessageData.Exprs) → motive t | false |
QuadraticMap.coeFn_smul._simp_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Monoid S]
[inst_6 : DistribMulAction S N] [inst_7 : SMulCommClass S R N] (a : S) (Q : QuadraticMap R M N), a • ⇑Q = ⇑(a • Q) | false |
LowerSet.iicInfHom_apply | Mathlib.Order.UpperLower.Hom | ∀ {α : Type u_1} [inst : SemilatticeInf α] (a : α), LowerSet.iicInfHom a = LowerSet.Iic a | true |
Lean.Compiler.LCNF.TrivialStructureInfo.casesOn | Lean.Compiler.LCNF.Irrelevant | {motive : Lean.Compiler.LCNF.TrivialStructureInfo → Sort u} →
(t : Lean.Compiler.LCNF.TrivialStructureInfo) →
((ctorName : Lean.Name) →
(numParams fieldIdx : ℕ) → motive { ctorName := ctorName, numParams := numParams, fieldIdx := fieldIdx }) →
motive t | false |
Lean.Syntax.replaceM | Lean.Syntax | {m : Type → Type} → [Monad m] → (Lean.Syntax → m (Option Lean.Syntax)) → Lean.Syntax → m Lean.Syntax | true |
NNRat.lt_def | Mathlib.Data.NNRat.Defs | ∀ {p q : ℚ≥0}, p < q ↔ p.num * q.den < q.num * p.den | true |
PiTensorProduct.lifts.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (x : PiTensorProduct R fun i => s i), x.lifts = {p | ↑p = x} | true |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.toReal_klDiv_smul_right._simp_1_6 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
Mathlib.Tactic.BicategoryLike.CoherenceHom.tgt | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.CoherenceHom → Mathlib.Tactic.BicategoryLike.Mor₁ | true |
SubMulAction.ofStabilizer.conjMap_comp | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {g h k : G} {a b c : α} (hg : b = g • a)
(hh : c = h • b) (hk : c = k • a) (H : k = h * g),
(SubMulAction.ofStabilizer.conjMap hh).comp (SubMulAction.ofStabilizer.conjMap hg) =
SubMulAction.ofStabilizer.conjMap hk | true |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.add_aux_right.match_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(motive : (y1 y2 : ℕ × K) → PerfectClosure.R K p y1 y2 → Prop) (y1 y2 : ℕ × K) (H : PerfectClosure.R K p y1 y2),
(∀ (n : ℕ) (y : K), motive (n, y) (n + 1, (frobenius K p) y) ⋯) → motive y1 y2 H | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_9 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_5} [inst_1 : CommRing K] [inst_2 : Algebra R K] [IsFractionRing R K]
{a b : R}, (↑a = ↑b) = (a = b) | false |
Real.le_sqrt_of_sq_le | Mathlib.Data.Real.Sqrt | ∀ {x y : ℝ}, x ^ 2 ≤ y → x ≤ √y | true |
RingPreordering.support_eq_bot | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {F : Type u_2} [inst : Field F] (P : RingPreordering F), P.support = ⊥ | true |
LeftInvariantDerivation.hasIntScalar | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | {𝕜 : 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} →
{G : Type u_4} →
[inst_4 : TopologicalSpace G] →
[inst_5 : ChartedSpace H G] →
[inst_6 : Monoid G] → [inst_7 : ContMDiffMul I (↑⊤) G] → SMul ℤ (LeftInvariantDerivation I G) | true |
FirstOrder.Language.BoundedFormula.toPrenexImp.eq_def | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (x_1 x_2 : L.BoundedFormula α x),
x_1.toPrenexImp x_2 =
match x, x_1, x_2 with
| n, (φ.imp FirstOrder.Language.BoundedFormula.falsum).all.imp FirstOrder.Language.BoundedFormula.falsum, ψ =>
(φ.toPrenexImp (FirstOrder.Language.BoundedFormula.liftAt 1 n ψ)).all
| n, φ.all, ψ => (φ.toPrenexImp (FirstOrder.Language.BoundedFormula.liftAt 1 n ψ)).ex
| x, φ, ψ => φ.toPrenexImpRight ψ | true |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.InteractiveGoal.1490754142._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Type | false |
SeparationQuotient.instNonAssocRing._proof_16 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocRing R] (n : ℤ), SeparationQuotient.mk ↑n = ↑n | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mem_splitSupport_iff_nonzero._simp_1_6 | Mathlib.Data.Finsupp.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
CategoryTheory.MorphismProperty.instHasIsosPrecoverageOfContainsIdentitiesOfRespectsIso | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[P.ContainsIdentities] [P.RespectsIso], P.precoverage.HasIsos | true |
Lean.IR.EmitLLVM.ShouldForwardControlFlow.no.sizeOf_spec | Lean.Compiler.IR.EmitLLVM | sizeOf Lean.IR.EmitLLVM.ShouldForwardControlFlow.no = 1 | true |
List.getElem?_mapIdx | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α} {i : ℕ}, (List.mapIdx f l)[i]? = Option.map (f i) l[i]? | true |
Std.Iter.Total | Init.Data.Iterators.Consumers.Total | {α : Type w} → Type w → Type w | true |
ODE.FunSpace.mk.injEq | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {r L : NNReal}
(toFun : ↑(Set.Icc tmin tmax) → E) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r) (toFun_1 : ↑(Set.Icc tmin tmax) → E)
(lipschitzWith_1 : LipschitzWith L toFun_1) (mem_closedBall₀_1 : toFun_1 t₀ ∈ Metric.closedBall x₀ ↑r),
({ toFun := toFun, lipschitzWith := lipschitzWith, mem_closedBall₀ := mem_closedBall₀ } =
{ toFun := toFun_1, lipschitzWith := lipschitzWith_1, mem_closedBall₀ := mem_closedBall₀_1 }) =
(toFun = toFun_1) | true |
Std.ExtTreeMap.size_filterMap_eq_size_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → Option γ},
(Std.ExtTreeMap.filterMap f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), (f (t.getKey k h) t[k]).isSome = true | true |
Int16.iSizeMinValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int16), ISize.minValue.toInt ≤ x.toInt | true |
Std.DHashMap.Raw.isSome_getKey?_iff_mem._simp_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._auto_478 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | false |
act_rel_of_rel_of_act_rel | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop} [CovariantClass M N μ r] [IsTrans N r] (m : M)
{a b c : N}, r a b → r (μ m b) c → r (μ m a) c | true |
Fintype.subtype_card | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {p : α → Prop} (s : Finset α) (H : ∀ (x : α), x ∈ s ↔ p x), Fintype.card { x // p x } = s.card | true |
isPathConnected_stdSimplex | Mathlib.Analysis.Convex.StdSimplex | ∀ (ι : Type u_1) [inst : Fintype ι] [Nonempty ι], IsPathConnected (stdSimplex ℝ ι) | true |
IsDedekindDomain.FiniteAdeleRing.instAlgebra | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → Algebra K (IsDedekindDomain.FiniteAdeleRing R K) | true |
HahnSeries.ofFinsupp._proof_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R], { coeff := ⇑0, isPWO_support' := ⋯ } = 0 | false |
AddRightCancelMonoid.toIsRightCancelAdd | Mathlib.Algebra.Group.Defs | ∀ {M : Type u} [self : AddRightCancelMonoid M], IsRightCancelAdd M | true |
ContinuousMap.sigmaMk._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_2} {X : I → Type u_1} [inst : (i : I) → TopologicalSpace (X i)] (i : I), Continuous (Sigma.mk i) | false |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_22 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C (n + 3)},
S.IsComplex →
∀ (k : ℕ) (hk : k ≤ n),
CategoryTheory.CategoryStruct.comp (S.map' (k + 1) (k + 1 + 1) ⋯ ⋯) (S.map' (k + 1 + 1) (k + 1 + 2) ⋯ ⋯) = 0 | false |
Std.TreeMap.Raw.getElem?_inter_of_not_mem_left | 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 : α}, k ∉ t₁ → (t₁ ∩ t₂)[k]? = none | true |
Lean.ScopedEnvExtension.Entry.scoped.inj | Lean.ScopedEnvExtension | ∀ {α : Type} {a : Lean.Name} {a_1 : α} {a_2 : Lean.Name} {a_3 : α},
Lean.ScopedEnvExtension.Entry.scoped a a_1 = Lean.ScopedEnvExtension.Entry.scoped a_2 a_3 → a = a_2 ∧ a_1 = a_3 | true |
Std.DTreeMap.Internal.Impl.aux_size_modify | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.LawfulEqOrd α] {k : α} {f : β k → β k}
{t : Std.DTreeMap.Internal.Impl α β}, (Std.DTreeMap.Internal.Impl.modify k f t).size = t.size | true |
OrderIso.bddAbove_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set α},
BddAbove (⇑e '' s) ↔ BddAbove s | true |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.encode.match_1.splitter | Mathlib.Tactic.DeriveEncodable | (motive : Mathlib.Deriving.Encodable.S✝ → Sort u_1) →
(x : Mathlib.Deriving.Encodable.S✝¹) →
((n : ℕ) → motive (Mathlib.Deriving.Encodable.S.nat✝ n)) →
((a b : Mathlib.Deriving.Encodable.S✝²) → motive (Mathlib.Deriving.Encodable.S.cons✝ a b)) → motive x | true |
BitVec.ne_of_lt | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x < y → x ≠ y | true |
Equiv.Perm.toList_eq_nil_iff | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {p : Equiv.Perm α} {x : α}, p.toList x = [] ↔ x ∉ p.support | true |
Lean.Meta.Grind.Arith.isRelevantPred | Lean.Meta.Tactic.Grind.Arith.IsRelevant | Lean.Expr → Lean.Meta.Grind.GoalM Bool | true |
ContMDiff.sumElim | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {M' : Type u_16} [inst_6 : TopologicalSpace M']
[inst_7 : ChartedSpace H M'] {n : WithTop ℕ∞} {E' : Type u_17} [inst_8 : NormedAddCommGroup E']
[inst_9 : NormedSpace 𝕜 E'] {H' : Type u_18} [inst_10 : TopologicalSpace H'] {J : ModelWithCorners 𝕜 E' H'}
{N : Type u_20} [inst_11 : TopologicalSpace N] [inst_12 : ChartedSpace H' N] {f : M → N} {g : M' → N},
ContMDiff I J n f → ContMDiff I J n g → ContMDiff I J n (Sum.elim f g) | true |
Std.TreeSet.merge | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet α cmp → Std.TreeSet α cmp → Std.TreeSet α cmp | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_inc._simp_1_2 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.insert._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Coalgebra.coassoc | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : AddCommMonoid A} {inst_2 : Module R A}
[self : Coalgebra R A],
↑(TensorProduct.assoc R A A A) ∘ₗ LinearMap.rTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul =
LinearMap.lTensor A CoalgebraStruct.comul ∘ₗ CoalgebraStruct.comul | true |
RootPairing.isSimpleModule_weylGroupRootRep | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : 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] (P : RootPairing ι R M N) [P.IsIrreducible],
IsSimpleModule (MonoidAlgebra R ↥P.weylGroup) P.weylGroupRootRep.asModule | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.