name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
HNNExtension.NormalWord.instFaithfulSMul_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) (d : HNNExtension.NormalWord.TransversalPair G A B),
FaithfulSMul (HNNExtension G A B φ) (HNNExtension.NormalWord d) | true |
String.Slice.Pattern.ForwardPattern.startsWith | Init.Data.String.Pattern.Basic | {ρ : Type} → (pat : ρ) → [self : String.Slice.Pattern.ForwardPattern pat] → String.Slice → Bool | true |
AkraBazziRecurrence.mk | Mathlib.Computability.AkraBazzi.SumTransform | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : Nonempty α] →
{T : ℕ → ℝ} →
{g : ℝ → ℝ} →
{a b : α → ℝ} →
{r : α → ℕ → ℕ} →
(n₀ : ℕ) →
0 < n₀ →
(∀ (i : α), 0 < a i) →
(∀ (i : α), 0 < b i) →
... | true |
Set.image_inv_Iic | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a : α),
Inv.inv '' Set.Iic a = Set.Ici a⁻¹ | true |
uniqueDiffWithinAt_congr | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s t : Set E} {x : E},
nhdsWithin x s = nhdsWithin x t → (UniqueDiffWithinAt 𝕜 s x ↔ UniqueDiffWithinAt 𝕜 t x) | true |
PowerBasis.basis_eq_pow | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_7} {S : Type u_8} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (self : PowerBasis R S)
(i : Fin self.dim), self.basis i = self.gen ^ ↑i | true |
CategoryTheory.PreGaloisCategory.instMulActionAutObjFiniteVFintypeCatFunctorObjActionFunctorToAction._proof_4 | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] (F : CategoryTheory.Functor C FintypeCat) (X : C)
(b : ((CategoryTheory.PreGaloisCategory.functorToAction F).obj X).V.obj), 1 • b = b | false |
MeasureTheory.Measure.instSMul._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {R : Type u_2} [inst : SMul R ENNReal] [inst_1 : IsScalarTower R ENNReal ENNReal]
{x : MeasurableSpace α} (c : R) (μ : MeasureTheory.Measure α), (c • μ.toOuterMeasure).trim ≤ c • μ.toOuterMeasure | false |
ContinuousMulEquiv.coe_mk' | 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] (f : M ≃ₜ N) (h : ∀ (x y : M), f (x * y) = f x * f y), ⇑(ContinuousMulEquiv.mk' f h) = ⇑f | true |
Int.emod_self_add_one | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ}, 0 ≤ x → x % (x + 1) = x | true |
PresheafOfModules.toFreeYonedaCoproduct.eq_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Generator | ∀ {C : Type u} [inst : CategoryTheory.SmallCategory C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
M.toFreeYonedaCoproduct =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel M.fromFreeYonedaCoproduct).fromFreeYonedaCoproduct
(CategoryTheory.Limits.kernel.ι M.fromFre... | true |
Part.pure_eq_some | Mathlib.Data.Part | ∀ {α : Type u_1} (a : α), pure a = Part.some a | true |
_private.Init.Data.Array.DecidableEq.0.Array.isEqv_eq_decide._simp_1_4 | Init.Data.Array.DecidableEq | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
AlgebraicGeometry.Flat.instOfSubsingletonCarrierCarrierCommRingCatOfIsIntegral | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [Subsingleton ↥Y] [AlgebraicGeometry.IsIntegral Y],
AlgebraicGeometry.Flat f | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.add_nf.match_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (o₁ o₂ : ONote) (motive : o₁.NF → o₂.NF → Prop) (x : o₁.NF) (x_1 : o₂.NF),
(∀ (b₁ : Ordinal.{0}) (h₁ : o₁.NFBelow b₁) (b₂ : Ordinal.{0}) (h₂ : o₂.NFBelow b₂), motive ⋯ ⋯) → motive x x_1 | false |
Finset.Ico_eq_filter_ssubsets | Mathlib.Data.Finset.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Finset α), Finset.Ico s t = {u ∈ t.ssubsets | s ⊆ u} | true |
ISize.toInt_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toInt = (↑n).bmod ISize.size | true |
Lean.Parser.Term.doMatchAlts | Lean.Parser.Do | Lean.Parser.Parser | true |
Subring.card_top | Mathlib.Algebra.Ring.Subring.Basic | ∀ (R : Type u_1) [inst : NonAssocRing R] [inst_1 : Fintype R], Fintype.card ↥⊤ = Fintype.card R | true |
MvPolynomial.aeval_bind₁ | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] (f : τ → S) (g : σ → MvPolynomial τ R) (φ : MvPolynomial σ R),
(MvPolynomial.aeval f) ((MvPolynomial.bind₁ g) φ) = (MvPolynomial.aeval fun i => (MvPolynomial.aeval f) (g i)) φ | true |
LTSeries.strictMono | Mathlib.Order.RelSeries | ∀ {α : Type u_1} [inst : Preorder α] (x : LTSeries α), StrictMono x.toFun | true |
OrderAddMonoidIso.comp_symm_eq | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(e : α ≃+o β) (f : β → α) (g : α → α), g ∘ ⇑e.symm = f ↔ g = f ∘ ⇑e | true |
Nat.maxPowDvdDiv_base_pow | Mathlib.Data.Nat.MaxPowDiv | ∀ {p : ℕ}, 1 < p → ∀ (k : ℕ), p.maxPowDvdDiv (p ^ k) = (k, 1) | true |
Std.DHashMap.Internal.Raw₀.size_alter_eq_self_of_not_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α],
(↑m).WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
m.contains k = false → (f (m.get? k)).isNone = true → (↑(m.alter k f)).size = (↑m).size | true |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.integral_Icc_deriv_smul_of_deriv_nonneg._proof_1_2 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {f : ℝ → ℝ} {a b : ℝ}, f '' Set.Ioo a b \ f '' Set.Icc a b = ∅ | false |
ModelWithCorners.isInteriorPoint_iff_not_isBoundaryPoint | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : 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] (x : M), I.IsInteriorPoint x ↔ ¬I.IsBou... | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.ENNReal.tendsto_sum_nat_add._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → NNReal}, Summable f → ∑' (a : α), ↑(f a) = ↑(tsum f) | false |
CategoryTheory.Limits.ChosenPullback₃.w₃_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | true |
Polynomial.trailingDegree_one | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] [Nontrivial R], Polynomial.trailingDegree 1 = 0 | true |
AlternatingMap.instModuleAddCommGroup | Mathlib.LinearAlgebra.ExteriorAlgebra.OfAlternating | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : AddCommGroup N] →
[inst_3 : Module R M] → [inst_4 : Module R N] → {ι : Type u_5} → Module R (M [⋀^ι]→ₗ[R] N) | true |
Ideal.mem_toTwoSided._simp_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] {x : R}, (x ∈ I.toTwoSided) = (x ∈ I) | false |
ValuativeExtension.mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : ValuativeRel A]
[inst_3 : ValuativeRel B] [inst_4 : Algebra A B],
(∀ (a b : A), (algebraMap A B) a ≤ᵥ (algebraMap A B) b ↔ a ≤ᵥ b) → ValuativeExtension A B | true |
Std.TreeSet.Raw.isSome_max?_iff_isEmpty_eq_false | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.max?.isSome = true ↔ t.isEmpty = false) | true |
monotonicSequenceLimitIndex | Mathlib.Order.OrderIsoNat | {α : Type u_1} → [inst : Preorder α] → (ℕ →o α) → ℕ | true |
USize.shiftLeft_and | Init.Data.UInt.Bitwise | ∀ {a b c : USize}, (a &&& b) <<< c = a <<< c &&& b <<< c | true |
SimpleGraph.IsClique.subsingleton | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {s : Set α}, ⊥.IsClique s → s.Subsingleton | true |
_private.Init.Data.List.Nat.InsertIdx.0.List.getElem?_insertIdx._proof_1_1 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} {l : List α} {x : α} {i j : ℕ}, j = i → i ≤ l.length → ¬j ≤ l.length → False | false |
ChartedSpace.locallyRingedSpaceMap | 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} →
... | true |
CategoryTheory.unmop_hom_leftUnitor | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᴹᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom.unmop =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X.unmop).hom | true |
CochainComplex.HomComplex.Cochain.rightShiftLinearEquiv_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (R : Type u_1)
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] (K L : CochainComplex C ℤ) (n a n' : ℤ) (hn' : n' + a = n)
(a_1 : CochainComplex.HomComplex.Cochain K L n),
(CochainComplex.HomComplex.Cochain.righ... | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.neg | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.EqCnstr → Lean.Meta.Grind.Arith.Linear.EqCnstrProof | true |
IsOrderedCancelSMul.mk | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} [inst : LE G] [inst_1 : LE P] [inst_2 : SMul G P] [toIsOrderedSMul : IsOrderedSMul G P],
(∀ (a : G) (b c : P), a • b ≤ a • c → b ≤ c) → (∀ (a b : G) (c : P), a • c ≤ b • c → a ≤ b) → IsOrderedCancelSMul G P | true |
modelWithCornersEuclideanHalfSpace._proof_3 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (n : ℕ) [inst : NeZero n] (x : EuclideanSpace ℝ (Fin n)),
0 ≤ (WithLp.toLp 2 (Function.update x.ofLp 0 (max (x.ofLp 0) 0))).ofLp 0 | false |
UpperHalfPlane.exists_SL2_smul_eq_of_apply_zero_one_eq_zero | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℝ), ↑g 1 0 = 0 → ∃ u v, (fun x => g • x) = (fun x => v +ᵥ x) ∘ fun x => u • x | true |
Mathlib.Meta.Positivity.evalERealDiv | Mathlib.Data.EReal.Inv | Mathlib.Meta.Positivity.PositivityExt | true |
Set.partiallyWellOrderedOn_iff_finite_antichains | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} {s : Set α} [Std.Refl r] [Std.Symm r],
s.PartiallyWellOrderedOn r ↔ ∀ t ⊆ s, IsAntichain r t → t.Finite | true |
Std.ExtTreeMap.minKeyD.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeMap α β cmp),
t = t_1 → ∀ (fallback fallback_1 : α), fallback = fallback_1 → t.minKeyD fallback = t_1.minKeyD fallback_1 | true |
Filter.instDiv | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [Div α] → Div (Filter α) | true |
Std.ExtHashSet.getD_union_of_not_mem_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k fallback : α}, k ∉ m₁ → (m₁ ∪ m₂).getD k fallback = m₂.getD k fallback | true |
Monovary.pow_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Monovary f g → ∀ (n : ℕ), Monovary f (g ^ n) | true |
Std.HashMap.Equiv.of_forall_mem_unit_iff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [LawfulBEq α] {m₁ m₂ : Std.HashMap α Unit},
(∀ (k : α), k ∈ m₁ ↔ k ∈ m₂) → m₁.Equiv m₂ | true |
FreeGroup.map_pure | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α β : Type u} (f : α → β) (x : α), f <$> pure x = pure (f x) | true |
Set.iInter_sum | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : α ⊕ β → Set γ}, ⋂ x, s x = (⋂ x, s (Sum.inl x)) ∩ ⋂ x, s (Sum.inr x) | true |
Lean.Widget.PanelWidgetInstance.casesOn | Lean.Widget.UserWidget | {motive : Lean.Widget.PanelWidgetInstance → Sort u} →
(t : Lean.Widget.PanelWidgetInstance) →
((toWidgetInstance : Lean.Widget.WidgetInstance) →
(range? : Option Lean.Lsp.Range) →
(name? : Option String) → motive { toWidgetInstance := toWidgetInstance, range? := range?, name? := name? }) →
... | false |
EuclideanGeometry.abs_oangle_right_toReal_lt_pi_div_two_of_dist_eq | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {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)]
{p₁ p₂ p₃ : P}, dist p₁ p₂ = dist p₁ p₃ → |(EuclideanGeometry.oangle p₁ p₂ p₃).toReal| <... | true |
Lean.OLeanLevel._sizeOf_1 | Lean.Environment | Lean.OLeanLevel → ℕ | false |
GroupWithZero.zpow_succ' | Mathlib.Algebra.GroupWithZero.Defs | ∀ {G₀ : Type u} [self : GroupWithZero G₀] (n : ℕ) (a : G₀),
GroupWithZero.zpow (↑n.succ) a = GroupWithZero.zpow (↑n) a * a | true |
CFC.abs_mul_self._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Abs | Lean.Syntax | false |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_20 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 a_2 : Turing.PartrecToTM2.Cont'), ¬Turing.PartrecToTM2.Cont'.comp a a_1 = a_2.cons₂ | false |
Option.instFaithfulVAdd | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {α : Type u_3} [inst : VAdd M α] [FaithfulVAdd M α], FaithfulVAdd M (Option α) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Int.Linear.Poly.pickVarToElim?.go._sunfold | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | ℤ → Int.Linear.Var → Int.Linear.Poly → ℤ × Int.Linear.Var | false |
ContMDiffWithinAt.comp' | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : 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] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | true |
CategoryTheory.ShortComplex.op_X₁ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), S.op.X₁ = Opposite.op S.X₃ | true |
Mathlib.Tactic.BicategoryLike.WhiskerRight.srcM._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.WhiskerRight → m Mathlib.Tactic.BicategoryLike.Mor₁ | false |
_private.Mathlib.Algebra.MvPolynomial.NoZeroDivisors.0.MvPolynomial.totalDegree_le_of_dvd_of_isDomain._proof_1_3 | Mathlib.Algebra.MvPolynomial.NoZeroDivisors | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R} (r : MvPolynomial σ R),
f.totalDegree ≤ f.totalDegree + r.totalDegree | false |
_private.Lean.Meta.Tactic.Assumption.0.Lean.MVarId.assumptionCore.match_1 | Lean.Meta.Tactic.Assumption | (motive : Option Lean.FVarId → Sort u_1) →
(__do_lift : Option Lean.FVarId) →
(Unit → motive none) → ((fvarId : Lean.FVarId) → motive (some fvarId)) → motive __do_lift | false |
IsAlgClosure.ofAlgebraic | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (K : Type u_1) (J : Type u_2) (L : Type v) [inst : Field K] [inst_1 : Field J] [inst_2 : Field L]
[inst_3 : Algebra K J] [inst_4 : Algebra J L] [IsAlgClosure J L] [inst_6 : Algebra K L] [IsScalarTower K J L]
[Algebra.IsAlgebraic K J], IsAlgClosure K L | true |
Std.TreeMap.self_le_maxKeyD_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β}
{fallback : α}, (cmp k ((t.insert k v).maxKeyD fallback)).isLE = true | true |
PreErgodic | Mathlib.Dynamics.Ergodic.Ergodic | {α : Type u_1} → {m : MeasurableSpace α} → (α → α) → autoParam (MeasureTheory.Measure α) PreErgodic._auto_1 → Prop | true |
Lean.Meta.RefinedDiscrTree.instToFormatKey | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Std.ToFormat Lean.Meta.RefinedDiscrTree.Key | true |
DFinsupp.coe_inf._simp_1 | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → SemilatticeInf (α i)]
(f g : Π₀ (i : ι), α i), ⇑f ⊓ ⇑g = ⇑(f ⊓ g) | false |
CategoryTheory.Subgroupoid.hom._proof_1 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_1} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (x : ↑S.objs),
↑(CategoryTheory.CategoryStruct.id x) = ↑(CategoryTheory.CategoryStruct.id x) | false |
_private.Mathlib.Data.Nat.Factorial.NatCast.0.IsUnit.natCast_factorial_of_isNilpotent._simp_1_1 | Mathlib.Data.Nat.Factorial.NatCast | ∀ {M : Type u_1} [inst : Monoid M] [IsDedekindFiniteMonoid M] {x y : M}, IsUnit (x * y) = (IsUnit x ∧ IsUnit y) | false |
Concept.extent_copy | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c : Concept α β r) (e : Set α) (i : Set β) (he : e = c.extent)
(hi : i = c.intent), (c.copy e i he hi).extent = e | true |
LieModuleHom.instInhabited | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.h | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof | true |
CategoryTheory.Limits.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
{W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.prod.map f g)
(CategoryTheory.Limits.prod.braiding Y W).hom =
CategoryTheory.CategoryStruct.comp (C... | true |
Lean.Meta.Grind.Arith.Linear.findRat | Lean.Meta.Tactic.Grind.Arith.Linear.Search | ℚ → ℚ → Array (ℚ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) → ℚ | true |
FirstOrder.Language.LHom.Injective.mk._flat_ctor | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {ϕ : L →ᴸ L'},
(∀ {n : ℕ}, Function.Injective fun f => ϕ.onFunction f) →
(∀ {n : ℕ}, Function.Injective fun R => ϕ.onRelation R) → ϕ.Injective | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.WithZero.expOrderIso._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (a ≤ b) = (↑a ≤ ↑b) | false |
Std.DTreeMap.Internal.Impl.getKeyD_eq_of_contains | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[Std.LawfulEqOrd α],
t.WF → ∀ {k fallback : α}, Std.DTreeMap.Internal.Impl.contains k t = true → t.getKeyD k fallback = k | true |
Order.Ideal.IsProper.notMem_of_compl_mem | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : BooleanAlgebra P] {x : P} {I : Order.Ideal P}, I.IsProper → xᶜ ∈ I → x ∉ I | true |
CategoryTheory.ComposableArrows.sc'MapIso_inv | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S₁ S₂ : CategoryTheory.ComposableArrows C n} (e : S₁ ≅ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex)
(i j k : ℕ) (hij : autoParam (i + 1 = j) CategoryTheory.ComposableArrows.sc'MapIso._auto_1)
... | true |
CategoryTheory.Functor.mapHomologicalComplex.congr_simp | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (F F_1 : CategoryTheory.Functor W₁ W₂) (e_F : F = F_1)
[inst_4 ... | true |
CategoryTheory.ShortComplex.ShortExact.hasInjectiveDimensionLT_X₁ | Mathlib.CategoryTheory.Abelian.Injective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C},
S.ShortExact →
∀ (n : ℕ),
CategoryTheory.HasInjectiveDimensionLT S.X₃ n →
CategoryTheory.HasInjectiveDimensionLT S.X₂ (n + 1) → CategoryTheory.HasInjectiveDimensionLT S... | true |
_private.Mathlib.Topology.CompactOpen.0.ContinuousMap.mem_nhds_iff._simp_1_2 | Mathlib.Topology.CompactOpen | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
UniqueFactorizationMonoid.induction_on_coprime | Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicative | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [UniqueFactorizationMonoid α] {P : α → Prop} (a : α),
P 0 →
(∀ {x : α}, IsUnit x → P x) →
(∀ {p : α} (i : ℕ), Prime p → P (p ^ i)) → (∀ {x y : α}, IsRelPrime x y → P x → P y → P (x * y)) → P a | true |
CategoryTheory.Ind.colimitPresentationCompYoneda._proof_2 | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.Ind C),
CategoryTheory.Limits.HasColimit (X.presentation.F.comp CategoryTheory.yoneda) | false |
Monoid.Foldl.ofFreeMonoid._proof_2 | Mathlib.Control.Fold | ∀ {α β : Type u_1} (f : β → α → β),
MulOpposite.op (flip (List.foldl f) (FreeMonoid.toList 1)) =
MulOpposite.op (flip (List.foldl f) (FreeMonoid.toList 1)) | false |
AddMonoidAlgebra.divOf_zero | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G]
(x : AddMonoidAlgebra k G), x.divOf 0 = x | true |
Std.DTreeMap.Raw.Const.contains_ofList | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (Std.DTreeMap.Raw.Const.ofList l cmp).contains k = (List.map Prod.fst l).contains k | true |
MvPolynomial.eval₂Hom_X' | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] (f : R →+* S₁)
(g : σ → S₁) (i : σ), (MvPolynomial.eval₂Hom f g) (MvPolynomial.X i) = g i | true |
List.Vector.mapAccumr₂_cons | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} {φ : Type u_5} {n : ℕ} {x : α} {y : β} {s : σ} (xs : List.Vector α n)
(ys : List.Vector β n) {f : α → β → σ → σ × φ},
List.Vector.mapAccumr₂ f (x ::ᵥ xs) (y ::ᵥ ys) s =
have r := List.Vector.mapAccumr₂ f xs ys s;
have q := f x y r.1;
(q.1, q.2 ::ᵥ r.2) | true |
Lean.Elab.Tactic.Omega.MetaProblem.mk._flat_ctor | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.Problem →
List Lean.Expr → List Lean.Expr → Std.HashSet Lean.Expr → Lean.Elab.Tactic.Omega.MetaProblem | false |
instIsAddLeftInvariantEuclideanHausdorffMeasureOfIsIsometricVAdd | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ {X : Type u_1} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] [inst_3 : AddGroup X]
[IsIsometricVAdd X X] (d : ℕ), (MeasureTheory.Measure.euclideanHausdorffMeasure d).IsAddLeftInvariant | true |
CategoryTheory.Precoverage.ZeroHypercover.instSmallOfSmallI₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C}
(E : J.ZeroHypercover S) [Small.{w', w} E.I₀], E.Small | true |
Lean.Meta.Simp.ConfigCtx.zetaDelta._inherited_default | Init.MetaTypes | Bool | false |
AddOpposite.instT2Space | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_1} [inst : TopologicalSpace M] [T2Space M], T2Space Mᵃᵒᵖ | true |
SimpleGraph.Dart.mk.injEq | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} {G : SimpleGraph V} (toProd : V × V) (adj : G.Adj toProd.1 toProd.2) (toProd_1 : V × V)
(adj_1 : G.Adj toProd_1.1 toProd_1.2),
({ toProd := toProd, adj := adj } = { toProd := toProd_1, adj := adj_1 }) = (toProd = toProd_1) | true |
Sum.instPreorderSum._proof_2 | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (x : α ⊕ β),
Sum.LiftRel (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) x x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.