name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AddSubgroup.finiteIndex_iInf' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Type u_3} {s : Finset ι} (f : ι → AddSubgroup G),
(∀ i ∈ s, (f i).FiniteIndex) → (⨅ i ∈ s, f i).FiniteIndex | true |
Finset.card_mul_singleton | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Mul α] [IsRightCancelMul α] [inst_2 : DecidableEq α] (s : Finset α) (a : α),
(s * {a}).card = s.card | true |
Affine.Triangle.sbtw_touchpoint_empty | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → Sbtw ℝ (t.points i₁) (Affine.Simplex.touchpoint t ∅ i₂) (t.points i₃) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Reify.0.Lean.Meta.Grind.Arith.Linear.assertNatCastNonneg | Lean.Meta.Tactic.Grind.Arith.Linear.Reify | Lean.Expr → Lean.Meta.Grind.Arith.Linear.LinearM Unit | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.tendsto_euler_sin_prod'._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Mathlib.Algebra.Order.Star.Pi.0.Pi.instStarOrderedRing.match_6 | Mathlib.Algebra.Order.Star.Pi | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : (i : ι) → NonUnitalSemiring (A i)] [inst_1 : (i : ι) → StarRing (A i)]
(x : (i : ι) → A i) (motive : (∃ y, ∀ (x_1 : ι), star (y x_1) * y x_1 = x x_1) → Prop)
(x_1 : ∃ y, ∀ (x_1 : ι), star (y x_1) * y x_1 = x x_1),
(∀ (y : (i : ι) → A i) (hy : ∀ (x_2 : ι), star (y x_2) * y x_2 = x x_2), motive ⋯) → motive x_1 | false |
CategoryTheory.PreZeroHypercover.isLimitSigmaOfIsColimitEquiv._proof_7 | Mathlib.CategoryTheory.Sites.CoproductSheafCondition | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
[inst_1 : E.HasPullbacks] {c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c)
[inst_2 : (E.sigmaOfIsColimit hc).HasPullbacks] (i j : E.I₀),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.Cofan.mk
(CategoryTheory.Limits.Cofan.mk ((E.sigmaOfIsColimit hc).toPreOneHypercover.Y PUnit.unit) fun b =>
CategoryTheory.Limits.pullback.map (E.f b.fst.1) (E.f b.fst.2) ((E.sigmaOfIsColimit hc).f PUnit.unit)
((E.sigmaOfIsColimit hc).f PUnit.unit) (c.inj b.fst.1) (c.inj b.fst.2)
(CategoryTheory.CategoryStruct.id S) ⋯ ⋯).pt
fun i =>
(CategoryTheory.Limits.Cofan.mk ((E.sigmaOfIsColimit hc).toPreOneHypercover.Y PUnit.unit) fun b =>
CategoryTheory.Limits.pullback.map (E.f b.fst.1) (E.f b.fst.2) ((E.sigmaOfIsColimit hc).f PUnit.unit)
((E.sigmaOfIsColimit hc).f PUnit.unit) (c.inj b.fst.1) (c.inj b.fst.2)
(CategoryTheory.CategoryStruct.id S) ⋯ ⋯).inj
((Equiv.sigmaPUnit (E.toPreOneHypercover.I₀ × E.toPreOneHypercover.I₀)).symm i)).inj
(i, j))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
(CategoryTheory.Limits.Cofan.mk
(CategoryTheory.Limits.Cofan.mk ((E.sigmaOfIsColimit hc).toPreOneHypercover.Y PUnit.unit) fun b =>
CategoryTheory.Limits.pullback.map (E.f b.fst.1) (E.f b.fst.2)
((E.sigmaOfIsColimit hc).f PUnit.unit) ((E.sigmaOfIsColimit hc).f PUnit.unit) (c.inj b.fst.1)
(c.inj b.fst.2) (CategoryTheory.CategoryStruct.id S) ⋯ ⋯).pt
fun i =>
(CategoryTheory.Limits.Cofan.mk ((E.sigmaOfIsColimit hc).toPreOneHypercover.Y PUnit.unit) fun b =>
CategoryTheory.Limits.pullback.map (E.f b.fst.1) (E.f b.fst.2)
((E.sigmaOfIsColimit hc).f PUnit.unit) ((E.sigmaOfIsColimit hc).f PUnit.unit) (c.inj b.fst.1)
(c.inj b.fst.2) (CategoryTheory.CategoryStruct.id S) ⋯ ⋯).inj
((Equiv.sigmaPUnit (E.toPreOneHypercover.I₀ × E.toPreOneHypercover.I₀)).symm i)).pt).hom
(CategoryTheory.Limits.pullback.snd ((E.sigmaOfIsColimit hc).f PUnit.unit)
((E.sigmaOfIsColimit hc).f PUnit.unit))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.snd
(E.f ((Equiv.sigmaPUnit (E.toPreOneHypercover.I₀ × E.toPreOneHypercover.I₀)).symm (i, j)).fst.1)
(E.f ((Equiv.sigmaPUnit (E.toPreOneHypercover.I₀ × E.toPreOneHypercover.I₀)).symm (i, j)).fst.2))
(c.inj j) | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.zero_le_pairingIn_of_root_sub_mem._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
TendstoUniformlyOn.div | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α] {ι : Type u_3}
{l : Filter ι} {f f' : ι → β → α} {g g' : β → α} {s : Set β},
TendstoUniformlyOn f g l s → TendstoUniformlyOn f' g' l s → TendstoUniformlyOn (f / f') (g / g') l s | true |
AddGroupSeminorm.smul_sup | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {R : Type u_1} {E : Type u_3} [inst : AddGroup E] [inst_1 : SMul R ℝ] [inst_2 : SMul R NNReal]
[inst_3 : IsScalarTower R NNReal ℝ] (r : R) (p q : AddGroupSeminorm E), r • (p ⊔ q) = r • p ⊔ r • q | true |
PowerSeries.coe_rescaleAlgHom | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (r : R), ↑(PowerSeries.rescaleAlgHom r) = PowerSeries.rescale r | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._simp_1_2 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
List.Pairwise R l = ∀ (i j : ℕ) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j] | false |
_private.Mathlib.Algebra.Algebra.Subalgebra.Basic.0.AlgHom.rangeRestrict_surjective.match_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (_y : B) (motive : _y ∈ f.range → Prop)
(hy : _y ∈ f.range), (∀ (x : A) (hx : f.toRingHom x = _y), motive ⋯) → motive hy | false |
_private.Mathlib.Algebra.Order.Interval.Set.Instances.0.Set.Ioo.one_sub_mem._simp_1_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, (0 < a - b) = (b < a) | false |
_private.Mathlib.Data.Nat.Choose.Multinomial.0.Nat.multinomial_congr_of_sdiff._proof_1_1 | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} [inst : DecidableEq α] {f : α → ℕ} {s t : Finset α}, s ⊆ t → ∀ a ∈ s \ t, f a = 0 | false |
Units.inv_eq_val_inv | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a : αˣ), a.inv = ↑a⁻¹ | true |
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal | Mathlib.MeasureTheory.Function.L2Space | {α : Type u_1} →
{E : Type u_2} →
{𝕜 : Type u_4} →
[inst : RCLike 𝕜] →
[inst_1 : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_2 : NormedAddCommGroup E] → [InnerProductSpace 𝕜 E] → Inner 𝕜 ↥(MeasureTheory.Lp E 2 μ) | true |
Nat.eq_two_pow_or_exists_odd_prime_and_dvd | Mathlib.Data.Nat.Factors | ∀ (n : ℕ), (∃ k, n = 2 ^ k) ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.tendsto_eVariationOn_Icc_zero_left._simp_1_2 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | false |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.measurable_div_const'._simp_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {inst : MeasurableSpace M} {inst_1 : Mul M} [self : MeasurableMul M] (c : M),
(Measurable fun x => x * c) = True | false |
Continuous.enorm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_8} [inst_2 : TopologicalSpace X]
{f : X → E}, Continuous f → Continuous fun x => ‖f x‖ₑ | true |
CompleteLat.Iso.mk | Mathlib.Order.Category.CompleteLat | {α β : CompleteLat} → ↑α ≃o ↑β → (α ≅ β) | true |
CategoryTheory.EnrichedFunctor.comp_map | Mathlib.CategoryTheory.Enriched.Basic | ∀ (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
{D : Type u₂} {E : Type u₃} [inst_2 : CategoryTheory.EnrichedCategory V C]
[inst_3 : CategoryTheory.EnrichedCategory V D] [inst_4 : CategoryTheory.EnrichedCategory V E]
(F : CategoryTheory.EnrichedFunctor V C D) (G : CategoryTheory.EnrichedFunctor V D E) (x x_1 : C),
(CategoryTheory.EnrichedFunctor.comp V F G).map x x_1 =
CategoryTheory.CategoryStruct.comp (F.map x x_1) (G.map (F.obj x) (F.obj x_1)) | true |
tendsto_atTop_iSup | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α] [inst_2 : CompleteLattice α]
[SupConvergenceClass α] {f : ι → α}, Monotone f → Filter.Tendsto f Filter.atTop (nhds (⨆ i, f i)) | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_sq_not_dvd_a_add_eta_sq_mul_b._simp_1_3 | Mathlib.NumberTheory.FLT.Three | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | false |
Nucleus.coe_toInfHom | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] (n : Nucleus X), ⇑n.toInfHom = ⇑n | true |
ImplicitFunctionData.hasStrictFDerivAt | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 : NormedSpace 𝕜 G] [inst_9 : CompleteSpace G] (φ : ImplicitFunctionData 𝕜 E F G),
HasStrictFDerivAt φ.prodFun (↑(φ.leftDeriv.equivProdOfSurjectiveOfIsCompl φ.rightDeriv ⋯ ⋯ ⋯)) φ.pt | true |
SchwartzMap.toLp.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E] [inst_5 : OpensMeasurableSpace E]
[inst_6 : SecondCountableTopologyEither E F] (f : SchwartzMap E F) (p : ENNReal) (μ : MeasureTheory.Measure E)
[hμ : μ.HasTemperateGrowth], f.toLp p μ = MeasureTheory.MemLp.toLp ⇑f ⋯ | true |
List.IsChain.induction | Mathlib.Data.List.Chain | ∀ {α : Type u} {r : α → α → Prop} (p : α → Prop) (l : List α),
List.IsChain r l → (∀ ⦃x y : α⦄, r x y → p x → p y) → (∀ (lne : l ≠ []), p (l.head lne)) → ∀ i ∈ l, p i | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.toList_zip_of_finite_right._simp_1_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._proof_1_6 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ (a b : ℕ), b ≥ a + 1 → a ≤ b + 1 | false |
SchwartzMap.instAddCommGroup._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (x x_1 : SchwartzMap E F), ⇑(x + x_1) = ⇑(x + x_1) | false |
CategoryTheory.Functor.relativelyRepresentable.symmetryIso_inv | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {Y : D} {b : C} {f' : F.obj b ⟶ Y} (hf' : F.relativelyRepresentable f') {a : C}
{g : F.obj a ⟶ Y} (hg : F.relativelyRepresentable g) [inst_2 : F.Full] [inst_3 : F.Faithful],
(hf'.symmetryIso hg).inv = hg.symmetry hf' | true |
AddGroupExtension._sizeOf_inst | Mathlib.GroupTheory.GroupExtension.Defs | (N : Type u_1) →
(E : Type u_2) →
(G : Type u_3) →
{inst : AddGroup N} →
{inst_1 : AddGroup E} →
{inst_2 : AddGroup G} → [SizeOf N] → [SizeOf E] → [SizeOf G] → SizeOf (AddGroupExtension N E G) | false |
_private.Std.Data.Iterators.Combinators.Monadic.Zip.0.Std.Iterators.Types.Zip.instFinitenessRelation₂.match_3 | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type u_1 → Type u_2} {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ m β₁]
(motive : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m → Prop)
(x : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m),
(∀ (a : Option { out // ∃ it, it.IsPlausibleOutput out }) (b : Std.IterM.TerminationMeasures.Productive α₁ m),
motive (a, b)) →
motive x | false |
LinearMap.quotKerEquivOfSurjective_symm_apply | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂) (hf : Function.Surjective ⇑f) (x : M),
(f.quotKerEquivOfSurjective hf).symm (f x) = Submodule.Quotient.mk x | true |
Quiver.IsSStronglyConnected | Mathlib.Combinatorics.Quiver.ConnectedComponent | (V : Type u_2) → [Quiver V] → Prop | true |
_private.Mathlib.FieldTheory.SeparablyGenerated.0.exists_isTranscendenceBasis_and_isSeparable_of_linearIndepOn_pow_of_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_2} {K : Type u_3} {ι : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ι → K}
(motive :
(∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparable (↥(IntermediateField.adjoin k (a '' {i}ᶜ))) (a i)) →
Prop)
(x : ∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparable (↥(IntermediateField.adjoin k (a '' {i}ᶜ))) (a i)),
(∀ (i : ι)
(hi : (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparable (↥(IntermediateField.adjoin k (a '' {i}ᶜ))) (a i)),
motive ⋯) →
motive x | false |
StieltjesFunction.zero_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : R), ↑0 x = 0 | true |
subsetInfSet._proof_1 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] (t : Set ↑s),
t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s → sInf (Subtype.val '' t) ∈ s | false |
CategoryTheory.Grothendieck.comp.eq_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y Z : CategoryTheory.Grothendieck F} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.Grothendieck.comp f g =
{ base := CategoryTheory.CategoryStruct.comp f.base g.base,
fiber :=
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.CategoryStruct.comp ((F.map g.base).toFunctor.map f.fiber) g.fiber) } | true |
derivationQuotKerSq._proof_4 | 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] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
LinearMap.CompatibleSMul Ω[P⁄R] (TensorProduct P S Ω[P⁄R]) R P | false |
_private.Init.Data.List.Erase.0.List.eraseP_filterMap.match_1.eq_2 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : (y : β) → motive (some y)) (h_2 : Unit → motive none),
(match none with
| some y => h_1 y
| none => h_2 ()) =
h_2 () | true |
Lean.Meta.Grind.Arith.Linear.instMonadGetStructLinearM | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | Lean.Meta.Grind.Arith.Linear.MonadGetStruct Lean.Meta.Grind.Arith.Linear.LinearM | true |
MulOpposite.instAdd | Mathlib.Algebra.Opposites | {α : Type u_1} → [Add α] → Add αᵐᵒᵖ | true |
ContinuousOn.prodMk | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] {f : α → β} {g : α → γ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => (f x, g x)) s | true |
PrincipalSeg.ofElement | Mathlib.Order.InitialSeg | {α : Type u_4} → (r : α → α → Prop) → (a : α) → PrincipalSeg (Subrel r fun x => r x a) r | true |
Order.le_pred_iff._simp_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], (b ≤ Order.pred a) = (b < a) | false |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.IsDedekindDomain.quotientEquivPiOfProdEq._proof_3 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} (P : ι → Ideal R), (∀ (i : ι), Prime (P i)) → ∀ (i : ι), P i ≠ 0 | false |
AlgebraicGeometry.Scheme.Pullback.gluedLift._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
(s : CategoryTheory.Limits.PullbackCone f g) (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ s.fst 𝒰).I₀),
CategoryTheory.Limits.HasPullback s.fst (𝒰.f i) | false |
NumberField.instCommRingRingOfIntegers._proof_7 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (a : NumberField.RingOfIntegers K), a + 0 = a | false |
PresheafOfModules.pushforward₀._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ RingCat) (X : PresheafOfModules R),
{ app := fun X_1 => (CategoryTheory.CategoryStruct.id X).app (F.op.obj X_1), naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (PresheafOfModules.pushforward₀_obj F R X) | false |
CategoryTheory.Presieve.yonedaFamilyOfElements_fromCocone | Mathlib.CategoryTheory.Sites.SheafOfTypes | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
(R : CategoryTheory.Presieve X) →
(s : CategoryTheory.Limits.Cocone R.diagram) →
CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.yoneda.obj s.pt) R | true |
AffineSubspace.smul_vsub_vadd_mem | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (self : AffineSubspace k P) (c : k) {p₁ p₂ p₃ : P},
p₁ ∈ self.carrier → p₂ ∈ self.carrier → p₃ ∈ self.carrier → c • (p₁ -ᵥ p₂) +ᵥ p₃ ∈ self.carrier | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerYield | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : Std.IterM m β},
it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂') →
Std.Iterators.Types.Flatten.IsPlausibleStep { internalState := { it₁ := it₁, it₂ := none } }
(Std.IterStep.skip { internalState := { it₁ := it₁', it₂ := some it₂' } }) | true |
RelSeries.ctorIdx | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → RelSeries r → ℕ | false |
CategoryTheory.IsMonHom.one_hom._autoParam | Mathlib.CategoryTheory.Monoidal.Mon_ | Lean.Syntax | false |
_private.Qq.ForLean.ToExpr.0.toExprLevel.match_1 | Qq.ForLean.ToExpr | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((l : Lean.Level) → motive l.succ) →
((l₁ l₂ : Lean.Level) → motive (l₁.max l₂)) →
((l₁ l₂ : Lean.Level) → motive (l₁.imax l₂)) →
((n : Lean.Name) → motive (Lean.Level.param n)) →
((n : Lean.LMVarId) → motive (Lean.Level.mvar n)) → motive x | false |
SimpleGraph.instMax | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → Max (SimpleGraph V) | true |
DirectSum.liftRingHom._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} {R : Type u_3} [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] [inst_4 : Semiring R]
(f :
{ f //
f GradedMonoid.GOne.one = 1 ∧ ∀ {i j : ι} (ai : A i) (aj : A j), f (GradedMonoid.GMul.mul ai aj) = f ai * f aj }),
(fun F => ⟨fun {i} => (↑F).comp (DirectSum.of A i), ⋯⟩) ((fun f => DirectSum.toSemiring (fun x => ↑f) ⋯ ⋯) f) = f | false |
_private.Mathlib.MeasureTheory.Measure.Haar.NormedSpace.0.MeasureTheory.Measure.setIntegral_comp_smul._simp_1_1 | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {s : Set γ}, f ⁻¹' (g ⁻¹' s) = g ∘ f ⁻¹' s | false |
Rep.Hom.noConfusionType | Mathlib.RepresentationTheory.Rep.Basic | Sort u_1 →
{k : Type u} →
{G : Type v} →
[inst : Semiring k] →
[inst_1 : Monoid G] →
{A B : Rep.{w, u, v} k G} →
A.Hom B →
{k' : Type u} →
{G' : Type v} →
[inst' : Semiring k'] → [inst'_1 : Monoid G'] → {A' B' : Rep.{w, u, v} k' G'} → A'.Hom B' → Sort u_1 | false |
_private.Mathlib.RingTheory.PowerSeries.NoZeroDivisors.0.PowerSeries.instNoZeroDivisors._simp_1 | Mathlib.RingTheory.PowerSeries.NoZeroDivisors | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, (φ = 0) = (φ.order = ⊤) | false |
TopologicalSpace.IsTopologicalBasis.of_isOpen_of_subset | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s s' : Set (Set α)},
(∀ u ∈ s', IsOpen u) → TopologicalSpace.IsTopologicalBasis s → s ⊆ s' → TopologicalSpace.IsTopologicalBasis s' | true |
Lean.Parser.Tactic.Grind.grindAdmit | Init.Grind.Interactive | Lean.ParserDescr | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_2 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
¬acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) → False | false |
CategoryTheory.Limits.HasCountableCoproducts.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableCoproducts C → Sort u} →
(t : CategoryTheory.Limits.HasCountableCoproducts C) →
((out : ∀ (J : Type) [Countable J], CategoryTheory.Limits.HasCoproductsOfShape J C) → motive ⋯) → motive t | false |
_private.Mathlib.Geometry.Manifold.Instances.Real.0.modelWithCornersEuclideanHalfSpace._simp_6 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (𝕜 : Type u_3) [h : RCLike 𝕜], IsRCLikeNormedField 𝕜 = True | false |
_private.Lean.Server.Completion.ImportCompletion.0.ImportCompletion.computePartialImportCompletions.match_6 | Lean.Server.Completion.ImportCompletion | (motive : Option (Lean.Name × String) → Sort u_1) →
(x : Option (Lean.Name × String)) →
((completePrefix : Lean.Name) → (incompleteSuffix : String) → motive (some (completePrefix, incompleteSuffix))) →
((x : Option (Lean.Name × String)) → motive x) → motive x | false |
TrivSqZeroExt.invertibleFstOfInvertible._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M]
[inst_3 : Module R M] (x : TrivSqZeroExt R M) [inst_4 : Invertible x], x.fst * (⅟x).fst = 1 | false |
PNat.natPred_eq_pred | Mathlib.Data.PNat.Defs | ∀ {n : ℕ} (h : 0 < n), PNat.natPred ⟨n, h⟩ = n.pred | true |
List.modify_succ_cons | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (a : α) (l : List α) (i : ℕ), (a :: l).modify (i + 1) f = a :: l.modify i f | true |
Finset.card_le_of_interleaved | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s t : Finset α},
(∀ x ∈ s, ∀ y ∈ s, x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) → s.card ≤ t.card + 1 | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.IntervalIntegrable.intervalIntegrable_slope._proof_1_3 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → 0 ≤ c → Set.uIcc a b ⊆ Set.uIcc a (b + c) | false |
DyckWord.toTree | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → Tree Unit | true |
AddEquiv.ext | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f g : M ≃+ N}, (∀ (x : M), f x = g x) → f = g | true |
IsLocalMax.norm_add_self | Mathlib.Analysis.Normed.Module.Extr | ∀ {X : Type u_2} {E : Type u_3} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] [inst_2 : TopologicalSpace X]
{f : X → E} {c : X}, IsLocalMax (norm ∘ f) c → IsLocalMax (fun x => ‖f x + f c‖) c | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk._flat_ctor | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Int.Linear.Poly → Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Lean.Meta.Grind.Arith.Cutsat.LeCnstr | false |
Batteries.RBNode.append._unary.eq_def | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} (_x : (_ : Batteries.RBNode α) ×' Batteries.RBNode α),
Batteries.RBNode.append._unary _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| Batteries.RBNode.nil, x => x
| x, Batteries.RBNode.nil => x
| Batteries.RBNode.node Batteries.RBColor.red a x b, Batteries.RBNode.node Batteries.RBColor.red c y d =>
match Batteries.RBNode.append._unary ⟨b, c⟩ with
| Batteries.RBNode.node Batteries.RBColor.red b' z c' =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red a x b') z
(Batteries.RBNode.node Batteries.RBColor.red c' y d)
| bc => Batteries.RBNode.node Batteries.RBColor.red a x (Batteries.RBNode.node Batteries.RBColor.red bc y d)
| Batteries.RBNode.node Batteries.RBColor.black a x b, Batteries.RBNode.node Batteries.RBColor.black c y d =>
match Batteries.RBNode.append._unary ⟨b, c⟩ with
| Batteries.RBNode.node Batteries.RBColor.red b' z c' =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.black a x b') z
(Batteries.RBNode.node Batteries.RBColor.black c' y d)
| bc => a.balLeft x (Batteries.RBNode.node Batteries.RBColor.black bc y d)
| a@h:(Batteries.RBNode.node Batteries.RBColor.black l v r), Batteries.RBNode.node Batteries.RBColor.red b x c =>
Batteries.RBNode.node Batteries.RBColor.red (Batteries.RBNode.append._unary ⟨a, b⟩) x c
| Batteries.RBNode.node Batteries.RBColor.red a x b, c@h:(Batteries.RBNode.node Batteries.RBColor.black l v r) =>
Batteries.RBNode.node Batteries.RBColor.red a x (Batteries.RBNode.append._unary ⟨b, c⟩) | false |
Aesop.UnsafeQueue.instEmptyCollection | Aesop.Tree.UnsafeQueue | EmptyCollection Aesop.UnsafeQueue | true |
_private.Init.Data.List.MapIdx.0.Option.getD.match_1.splitter | Init.Data.List.MapIdx | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.filter._proof_1 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} (f : (a : α) → β a → Bool) (m m' : Std.DHashMap α β),
m.Equiv m' → Std.ExtDHashMap.mk (Std.DHashMap.filter f m) = Std.ExtDHashMap.mk (Std.DHashMap.filter f m') | false |
MeasureTheory.SimpleFunc.bind._proof_2 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β)
(g : β → MeasureTheory.SimpleFunc α γ) (c : γ), MeasurableSet {a | (g (f a)) a = c} | false |
Tropical.instLinearOrderTropical._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (a b : Tropical R),
Tropical.untrop (a + b) = Tropical.untrop (if a ≤ b then a else b) | false |
CategoryTheory.CommGrp.forget₂CommMon_map_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {A B : CategoryTheory.CommGrp C} (f : A ⟶ B),
((CategoryTheory.CommGrp.forget₂CommMon C).map f).hom = f.hom.hom | true |
CategoryTheory.prodComonad._proof_10 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProducts C] (X_1 : C),
CategoryTheory.CategoryStruct.comp
({
app := fun x =>
CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Limits.prod.functor.obj X).obj x)),
naturality := ⋯ }.app
X_1)
((CategoryTheory.Limits.prod.functor.obj X).map
({ app := fun x => CategoryTheory.Limits.prod.snd, naturality := ⋯ }.app X_1)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Limits.prod.functor.obj X).obj X_1) | false |
UInt64.toUInt8_or | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), (a ||| b).toUInt8 = a.toUInt8 ||| b.toUInt8 | true |
_private.Lean.Meta.Tactic.Grind.Anchor.0.Lean.Meta.Grind.getAnchor.match_4 | Lean.Meta.Tactic.Grind.Anchor | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((n : Lean.Name) → (v t b : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE n v t b nondep)) →
((n : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam n d b binderInfo)) →
((n : Lean.Name) →
(d b : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE n d b binderInfo)) →
((typeName : Lean.Name) → (i : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj typeName i s)) →
((idx : ℕ) → motive (Lean.Expr.bvar idx)) →
((v : Lean.Literal) → motive (Lean.Expr.lit v)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → motive e | false |
Lean.SCC.State.recOn | Lean.Util.SCC | {α : Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SCC.State α → Sort u} →
(t : Lean.SCC.State α) →
((stack : List α) →
(nextIndex : ℕ) →
(data : Std.HashMap α Lean.SCC.Data) →
(sccs : List (List α)) →
motive { stack := stack, nextIndex := nextIndex, data := data, sccs := sccs }) →
motive t | false |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_6 | Mathlib.RingTheory.Unramified.Finite | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | false |
FirstOrder.Language.LEquiv.symm_invLHom | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (e : L ≃ᴸ L'), e.symm.invLHom = e.toLHom | true |
CommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : CommGroup α] [inst_2 : MulLeftMono α],
CommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | true |
Ctop.Realizer.id._proof_1 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x x_1 : { x // IsOpen x }) (_a : α) (h : _a ∈ ↑x ∩ ↑x_1),
_a ∈
↑(match x, h with
| ⟨_x, h₁⟩, _h₃ =>
match x_1, _h₃ with
| ⟨_y, h₂⟩, _h₃ => ⟨_x ∩ _y, ⋯⟩) | false |
Lean.Lsp.CompletionClientCapabilities.casesOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
(t : Lean.Lsp.CompletionClientCapabilities) →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
motive t | false |
not_or._simp_3 | Mathlib.Tactic.Push | ∀ {p q : Prop}, (¬p ∧ ¬q) = ¬(p ∨ q) | false |
Vector.finRev?_push | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {p : α → Bool} {a : α} {xs : Vector α n},
Vector.findRev? p (xs.push a) = (Option.guard p a).or (Vector.findRev? p xs) | true |
Finset.sup_inf_sup | Mathlib.Data.Finset.Lattice.Prod | ∀ {α : Type u_2} {ι : Type u_5} {κ : Type u_6} [inst : DistribLattice α] [inst_1 : OrderBot α] (s : Finset ι)
(t : Finset κ) (f : ι → α) (g : κ → α), s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2 | true |
List.cons_sublist_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {a : α} {l l' : List α}, (a :: l).Sublist l' ↔ ∃ r₁ r₂, l' = r₁ ++ r₂ ∧ a ∈ r₁ ∧ l.Sublist r₂ | true |
Subring.toRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u_1} → [inst : Ring R] → (s : Subring R) → Ring ↥s | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.refineCore._sparseCasesOn_1 | Lean.Elab.Tactic.ElabTerm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.