name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
UpperSemicontinuousWithinAt.sup | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} {β : Type u_5} [inst : TopologicalSpace α] [inst_1 : LinearOrder β] {f g : α → β} {s : Set α} {a : α},
UpperSemicontinuousWithinAt f s a →
UpperSemicontinuousWithinAt g s a → UpperSemicontinuousWithinAt (fun x => max (f x) (g x)) s a | true |
CategoryTheory.uliftCoyonedaEquiv_symm_map | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
{F : CategoryTheory.Functor C (Type (max w v₁))} (t : F.obj X),
CategoryTheory.uliftCoyonedaEquiv.symm (F.map f t) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.uliftCoyoneda.{w, v₁, u₁}.map f.op)
(CategoryTheory.uliftCoyonedaEquiv.symm t) | true |
_private.Init.Data.List.Sublist.0.List.infix_cons.match_1_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α} (motive : l₁ <:+: l₂ → Prop) (x : l₁ <:+: l₂),
(∀ (l₁' l₂' : List α) (h : l₁' ++ l₁ ++ l₂' = l₂), motive ⋯) → motive x | false |
_private.Mathlib.Algebra.Homology.QuasiIso.0.instIsIsoHomologyMapOfQuasiIsoAt._simp_1 | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L : HomologicalComplex C c} (f : K ⟶ L)
(i : ι) [inst_2 : K.HasHomology i] [inst_3 : L.HasHomology i],
QuasiIsoAt f i = CategoryTheory.ShortComplex.QuasiIso ((HomologicalComplex.shortComplexFunctor C c i).map f) | false |
Quiver.reverse_inj._simp_1 | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {V : Type u_2} [inst : Quiver V] [h : Quiver.HasInvolutiveReverse V] {a b : V} (f g : a ⟶ b),
(Quiver.reverse f = Quiver.reverse g) = (f = g) | false |
connectedComponentsEquivZerothHomotopy._proof_1 | Mathlib.Topology.Connected.LocPathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocPathConnectedSpace X] (x1 x2 : X), x1 ≈ x2 → Joined x1 x2 | false |
groupHomology.cyclesMap_comp_isoCycles₁_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) {Z : ModuleCat k}
(h : ModuleCat.of k ↥(groupHomology.cycles₁ B) ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.cyclesMap f φ 1)
(CategoryTheory.CategoryStruct.comp (groupHomology.isoCycles₁ B).hom h) =
CategoryTheory.CategoryStruct.comp (groupHomology.isoCycles₁ A).hom
(CategoryTheory.CategoryStruct.comp (groupHomology.mapCycles₁ f φ) h) | true |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.map_preimage._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (f a ∈ s) = (a ∈ f ⁻¹' s) | false |
Lean.Elab.Tactic.evalRight._regBuiltin.Lean.Elab.Tactic.evalRight.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | false |
Aesop.StatsFileRecord.position | Aesop.Stats.File | Aesop.StatsFileRecord → Option Lean.Position | true |
_private.Mathlib.Algebra.Ring.Parity.0.Nat.odd_add._proof_1_1 | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, Odd (m + n) ↔ (Odd m ↔ Even n) | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip₀₁'._simp_1_7 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
_private.Mathlib.GroupTheory.Perm.Sign.0.Equiv.Perm.signBijAux_injOn._simp_1_2 | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | false |
CategoryTheory.Pseudofunctor.whiskerLeft_mapId_inv | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerLeft (F.map f) (F.mapId b).inv =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (F.map f)).hom
(CategoryTheory.CategoryStruct.comp (F.map₂ (CategoryTheory.Bicategory.rightUnitor f).inv)
(F.mapComp f (CategoryTheory.CategoryStruct.id b)).hom) | true |
Nat.shiftLeft_shiftRight | Init.Data.Nat.Lemmas | ∀ (x n : ℕ), x <<< n >>> n = x | true |
LinearOrder.mkOfGroupCone._proof_3 | Mathlib.Algebra.Order.Group.Cone | ∀ {S : Type u_2} {G : Type u_1} [inst : CommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : GroupConeClass S G]
[inst_3 : DecidablePred fun x => x ∈ C] (a b : G), (if a ≤ b then b else a) = if a ≤ b then b else a | false |
Real.arccos_le_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arccos x ≤ Real.pi / 2 ↔ 0 ≤ x | true |
List.Nat.antidiagonalTuple.match_1 | Mathlib.Data.Fin.Tuple.NatAntidiagonal | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) → (Unit → motive 0 0) → ((n : ℕ) → motive 0 n.succ) → ((k n : ℕ) → motive k.succ n) → motive x x_1 | false |
_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.map_inverseImage_le.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (P : CategoryTheory.MorphismProperty D)
(F : CategoryTheory.Functor C D) (x x_1 : D) (x_2 : x ⟶ x_1) (motive : (P.inverseImage F).map F x_2 → Prop)
(x_3 : (P.inverseImage F).map F x_2),
(∀ (w w_1 : C) (f : w ⟶ w_1) (hf : P.inverseImage F f)
(e : CategoryTheory.Arrow.mk (F.map f) ≅ CategoryTheory.Arrow.mk x_2), motive ⋯) →
motive x_3 | false |
Differential.differentialFiniteDimensional._proof_2 | Mathlib.FieldTheory.Differential.Basic | ∀ (F : Type u_2) [inst : Field F] [inst_1 : CharZero F] (K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra F K]
[inst_4 : FiniteDimensional F K], F⟮⋯.choose⟯ = ⊤ | false |
Finset.prod_Ioo_mul_eq_prod_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → (∏ x ∈ Finset.Ioo a b, f x) * f a = ∏ x ∈ Finset.Ico a b, f x | true |
FiniteGaloisIntermediateField.adjoin_simple_le_iff | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [inst_3 : IsGalois k K]
{x : K} {L : FiniteGaloisIntermediateField k K},
FiniteGaloisIntermediateField.adjoin k {x} ≤ L ↔ x ∈ L.toIntermediateField | true |
Derivation.compAlgebraMap | Mathlib.RingTheory.Derivation.Basic | {R : Type u_1} →
(A : Type u_2) →
{B : Type u_3} →
{M : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : CommSemiring B] →
[inst_3 : AddCommMonoid M] →
[inst_4 : Algebra R A] →
[inst_5 : Algebra R B] →
[inst_6 : Module A M] →
[inst_7 : Module B M] →
[inst_8 : Module R M] →
[inst_9 : Algebra A B] →
[IsScalarTower R A B] → [IsScalarTower A B M] → Derivation R B M → Derivation R A M | true |
Finsupp.subtypeDomain_eq_zero_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_5} [inst : Zero M] {p : α → Prop} {f : α →₀ M},
(∀ x ∈ f.support, p x) → (Finsupp.subtypeDomain p f = 0 ↔ f = 0) | true |
Vector.Mem.casesOn | Init.Data.Vector.Basic | {α : Type u_1} →
{n : ℕ} →
{xs : Vector α n} →
{a : α} → {motive : xs.Mem a → Sort u} → (t : xs.Mem a) → ((val : a ∈ xs.toArray) → motive ⋯) → motive t | false |
instCompleteLinearOrderEReal._proof_28 | Mathlib.Data.EReal.Basic | ∀ (a : EReal), ⊤ \ a = ￢a | false |
IsPrimitiveRoot.subOnePowerBasis | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | {n : ℕ} →
[NeZero n] →
(K : Type u) →
{L : Type v} →
[inst : Field K] →
[inst_1 : CommRing L] →
[IsDomain L] →
[inst_3 : Algebra K L] → [IsCyclotomicExtension {n} K L] → {ζ : L} → IsPrimitiveRoot ζ n → PowerBasis K L | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.lift_f' | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} [inst_3 : F.IsWellOrderContinuous] {j : J} (hj : Order.IsSuccLimit j)
(s : ↑(⋯.functor.op.comp (CategoryTheory.HasLiftingProperty.transfiniteComposition.sqFunctor c p f g)).sections),
(CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.lift hj s).f' =
CategoryTheory.HasLiftingProperty.transfiniteComposition.wellOrderInductionData.liftHom hj s | true |
UniformSpaceCat.hom_ext | Mathlib.Topology.Category.UniformSpace | ∀ {X Y : UniformSpaceCat} {f g : X ⟶ Y},
⇑(CategoryTheory.ConcreteCategory.hom f) = ⇑(CategoryTheory.ConcreteCategory.hom g) → f = g | true |
Field.sepDegree_eq_of_isPurelyInseparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [IsPurelyInseparable F E],
Field.sepDegree F K = Field.sepDegree E K | true |
_private.Mathlib.Algebra.Group.Basic.0.add_zsmul_add.match_1_1 | Mathlib.Algebra.Group.Basic | ∀ (motive : ℤ → Prop) (x : ℤ), (∀ (n : ℕ), motive (Int.ofNat n)) → (∀ (n : ℕ), motive (Int.negSucc n)) → motive x | false |
Set.unbounded_le_Ioi | Mathlib.Order.Bounded | ∀ {α : Type u_1} [inst : SemilatticeSup α] [NoMaxOrder α] (a : α), Set.Unbounded (fun x1 x2 => x1 ≤ x2) (Set.Ioi a) | true |
Std.DTreeMap.Internal.Impl.Const.minEntry?._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | false |
PadicInt.instCommRing._aux_32 | Mathlib.NumberTheory.Padics.PadicIntegers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → ℤ_[p] → ℤ_[p] | false |
List.zipWithLeftTR.go.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → Option β → γ) (x : List β) (x_1 : Array γ),
List.zipWithLeftTR.go f [] x x_1 = x_1.toList | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.instEpiModuleCatH1π._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G),
CategoryTheory.Epi (groupHomology.H1π A) | false |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s = 0) = ∀ (a : α), a ∉ s | false |
Std.DTreeMap.Raw.getKeyD_erase_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k fallback : α}, (t.erase k).getKeyD k fallback = fallback | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.minEntryD.match_1.eq_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → (a : α) × β a → Sort u_3)
(fallback : (a : α) × β a) (h_1 : (fallback : (a : α) × β a) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Impl α β) →
(x : (a : α) × β a) →
motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r) x)
(h_3 :
(size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r : Std.DTreeMap.Internal.Impl α β) →
l = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r →
(r_1 : Std.DTreeMap.Internal.Impl α β) →
(fallback : (a : α) × β a) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r) r_1)
fallback),
(match Std.DTreeMap.Internal.Impl.leaf, fallback with
| Std.DTreeMap.Internal.Impl.leaf, fallback => h_1 fallback
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => h_2 size k v r x
| Std.DTreeMap.Internal.Impl.inner size k v (l@h:(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r)) r_1,
fallback => h_3 size k v l size_1 k_1 v_1 l_1 r h r_1 fallback) =
h_1 fallback | true |
fwdDiff_addChar_eq | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_3} {R : Type u_4} [inst : AddCommMonoid M] [inst_1 : Ring R] (φ : AddChar M R) (x h : M) (n : ℕ),
(fwdDiff h)^[n] (⇑φ) x = (φ h - 1) ^ n * φ x | true |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_some_iff._simp_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {as : List α} {xs : Array α}, (as.toArray = xs) = (as = xs.toList) | false |
summable_geometric_iff_norm_lt_one._simp_1 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {K : Type u_4} [inst : NormedDivisionRing K] {ξ : K}, (Summable fun n => ξ ^ n) = (‖ξ‖ < 1) | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_pmap_idxOf?._simp_1_10 | Init.Data.List.Find | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | false |
SeminormFamily.basisSets_smul_right | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {R : Type u_1} {E : Type u_6} {ι : Type u_9} [inst : SeminormedRing R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(p : SeminormFamily R E ι) (v : E), ∀ U ∈ p.basisSets, ∀ᶠ (x : R) in nhds 0, x • v ∈ U | true |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowAsserted | Lean.Elab.Tactic.Grind.ShowState | Lean.Elab.Tactic.Grind.GrindTactic | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Functor.0.CategoryTheory.Functor.map_opShiftFunctorEquivalence_counitIso_inv_app_unop._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.unop f.unop = (CategoryTheory.CategoryStruct.comp f g).unop | false |
Function.Injective.addCommMonoidWithOne | Mathlib.Algebra.Ring.InjSurj | {R : Type u_1} →
{S : Type u_3} →
[inst : Zero S] →
[inst_1 : One S] →
[inst_2 : Add S] →
[inst_3 : SMul ℕ S] →
[inst_4 : NatCast S] →
[inst_5 : AddCommMonoidWithOne R] →
(f : S → R) →
Function.Injective f →
f 0 = 0 →
f 1 = 1 →
(∀ (x y : S), f (x + y) = f x + f y) →
(∀ (n : ℕ) (x : S), f (n • x) = n • f x) → (∀ (n : ℕ), f ↑n = ↑n) → AddCommMonoidWithOne S | true |
Lean.Widget.instToModuleUserWidgetDefinition._proof_1 | Lean.Widget.UserWidget | ∀ (uwd : Lean.Widget.UserWidgetDefinition), hash uwd.javascript = hash uwd.javascript | false |
CompactlySupportedContinuousMap.copy._proof_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β]
(f : CompactlySupportedContinuousMap α β) (f' : α → β), f' = ⇑f → HasCompactSupport f' | false |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M] [IsTopologicalAddGroup M], ContinuousAdd M | false |
Aesop.instInhabitedOptions.default | Aesop.Options.Public | Aesop.Options | true |
CategoryTheory.Subfunctor.epi_iff_range_eq_top | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)} (p : F' ⟶ F),
CategoryTheory.Epi p ↔ CategoryTheory.Subfunctor.range p = ⊤ | true |
IsApproximateSubgroup.casesOn | Mathlib.Combinatorics.Additive.ApproximateSubgroup | {G : Type u_1} →
[inst : Group G] →
{K : ℝ} →
{A : Set G} →
{motive : IsApproximateSubgroup K A → Sort u} →
(t : IsApproximateSubgroup K A) →
((one_mem : 1 ∈ A) → (inv_eq_self : A⁻¹ = A) → (sq_covBySMul : CovBySMul G K (A ^ 2) A) → motive ⋯) →
motive t | false |
Not.imp_symm | Mathlib.Logic.Basic | ∀ {a b : Prop}, (¬a → b) → ¬b → a | true |
Pi.infinite_of_left | Mathlib.Data.Fintype.Prod | ∀ {ι : Sort u_4} {π : ι → Type u_5} [∀ (i : ι), Nontrivial (π i)] [Infinite ι], Infinite ((i : ι) → π i) | true |
RegularExpression.ctorElimType | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} → ℕ → Sort (max 1 u_1 (imax (u + 1) u_1) (imax (u + 1) (u + 1) u_1)) | false |
NumberField.ComplexEmbedding.lift.congr_simp | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ (K : Type u_1) [inst : Field K] {k : Type u_2} [inst_1 : Field k] [inst_2 : Algebra k K]
[inst_3 : Algebra.IsAlgebraic k K] (φ φ_1 : k →+* ℂ),
φ = φ_1 → NumberField.ComplexEmbedding.lift K φ = NumberField.ComplexEmbedding.lift K φ_1 | true |
map_comp_neg | Mathlib.Algebra.Group.Hom.Defs | ∀ {ι : Type u_1} {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (g : ι → G), ⇑f ∘ (-g) = -⇑f ∘ g | true |
Lean.Parser.Term.letRecDecls.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
_private.Lean.Elab.PreDefinition.WF.Preprocess.0.Lean.Elab.WF.paramProj._sparseCasesOn_1 | Lean.Elab.PreDefinition.WF.Preprocess | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.MonadSimp.mk.noConfusion | Lean.Meta.MonadSimp | {m : Type → Type} →
{P : Sort u} →
{withNewLemmas : {α : Type} → Array Lean.Expr → m α → m α} →
{dsimp : Lean.Expr → m Lean.Expr} →
{simp : Lean.Expr → m Lean.Meta.MonadSimp.Result} →
{withNewLemmas' : {α : Type} → Array Lean.Expr → m α → m α} →
{dsimp' : Lean.Expr → m Lean.Expr} →
{simp' : Lean.Expr → m Lean.Meta.MonadSimp.Result} →
{ withNewLemmas := withNewLemmas, dsimp := dsimp, simp := simp } =
{ withNewLemmas := withNewLemmas', dsimp := dsimp', simp := simp' } →
(withNewLemmas ≍ withNewLemmas' → dsimp ≍ dsimp' → simp ≍ simp' → P) → P | false |
Topology._aux_Mathlib_Topology_Defs_Filter___delab_app_Topology_nhdsGT_1 | Mathlib.Topology.Defs.Filter | Lean.PrettyPrinter.Delaborator.Delab | false |
Lean.Server.instRpcEncodableProd.match_1 | Lean.Server.Rpc.Basic | {α β : Type} → (motive : α × β → Sort u_1) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x | false |
Mathlib.Tactic.nlinarith | Mathlib.Tactic.Linarith.Frontend | Lean.ParserDescr | true |
CategoryTheory.GradedObject.ιMapObjOrZero_mapMap_assoc | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X Y : CategoryTheory.GradedObject I C} (φ : X ⟶ Y) (p : I → J) [inst_1 : X.HasMap p] [inst_2 : Y.HasMap p]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_4 : DecidableEq J] (i : I) (j : J) {Z : C}
(h : Y.mapObj p j ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.ιMapObjOrZero p i j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.GradedObject.mapMap φ p j) h) =
CategoryTheory.CategoryStruct.comp (φ i) (CategoryTheory.CategoryStruct.comp (Y.ιMapObjOrZero p i j) h) | true |
IsPrimitiveRoot.minpoly_dvd_pow_mod | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K},
IsPrimitiveRoot μ n →
∀ [IsDomain K] [CharZero K] {p : ℕ} [hprime : Fact (Nat.Prime p)],
¬p ∣ n →
Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ μ) ∣
Polynomial.map (Int.castRingHom (ZMod p)) (minpoly ℤ (μ ^ p)) ^ p | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.noSibling_tail?.match_1_2 | Batteries.Data.PairingHeap | ∀ {α : Type u_1}
(motive :
(s' : Batteries.PairingHeapImp.Heap α) →
(x : Option (α × Batteries.PairingHeapImp.Heap α)) → Option.map (fun x => x.2) x = some s' → Prop)
(s' : Batteries.PairingHeapImp.Heap α) (x : Option (α × Batteries.PairingHeapImp.Heap α))
(eq : Option.map (fun x => x.2) x = some s'),
(∀ (a : α) (tl : Batteries.PairingHeapImp.Heap α),
x = some (a, tl) → motive ((fun x => x.2) (a, tl)) (some (a, tl)) ⋯) →
motive s' x eq | false |
ContinuousCohomology.MultiInd.d._unsafe_rec | Mathlib.Algebra.Category.ContinuousCohomology.Basic | (R : Type u_1) →
(G : Type u_2) →
[inst : CommRing R] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace R] →
[inst_3 : TopologicalSpace G] →
[inst_4 : IsTopologicalGroup G] →
(n : ℕ) → ContinuousCohomology.MultiInd.functor R G n ⟶ ContinuousCohomology.MultiInd.functor R G (n + 1) | false |
Lean.Doc.Block.rec_7 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1} →
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_7 : List (Lean.Doc.Block i b) → Sort u_1} →
{motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) → Sort u_1} →
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) → Sort u_1} →
((contents : Array (Lean.Doc.Inline i)) → motive_1 (Lean.Doc.Block.para contents)) →
((content : String) → motive_1 (Lean.Doc.Block.code content)) →
((items : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_2 items → motive_1 (Lean.Doc.Block.ul items)) →
((start : ℤ) →
(items : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_2 items → motive_1 (Lean.Doc.Block.ol start items)) →
((items : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
motive_3 items → motive_1 (Lean.Doc.Block.dl items)) →
((items : Array (Lean.Doc.Block i b)) →
motive_4 items → motive_1 (Lean.Doc.Block.blockquote items)) →
((content : Array (Lean.Doc.Block i b)) →
motive_4 content → motive_1 (Lean.Doc.Block.concat content)) →
((container : b) →
(content : Array (Lean.Doc.Block i b)) →
motive_4 content → motive_1 (Lean.Doc.Block.other container content)) →
((toList : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_5 toList → motive_2 { toList := toList }) →
((toList : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
motive_6 toList → motive_3 { toList := toList }) →
((toList : List (Lean.Doc.Block i b)) →
motive_7 toList → motive_4 { toList := toList }) →
motive_5 [] →
((head : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
(tail : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
motive_8 head → motive_5 tail → motive_5 (head :: tail)) →
motive_6 [] →
((head : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) →
(tail :
List
(Lean.Doc.DescItem (Lean.Doc.Inline i)
(Lean.Doc.Block i b))) →
motive_9 head → motive_6 tail → motive_6 (head :: tail)) →
motive_7 [] →
((head : Lean.Doc.Block i b) →
(tail : List (Lean.Doc.Block i b)) →
motive_1 head → motive_7 tail → motive_7 (head :: tail)) →
((contents : Array (Lean.Doc.Block i b)) →
motive_4 contents → motive_8 { contents := contents }) →
((term : Array (Lean.Doc.Inline i)) →
(desc : Array (Lean.Doc.Block i b)) →
motive_4 desc →
motive_9 { term := term, desc := desc }) →
(t : Lean.Doc.ListItem (Lean.Doc.Block i b)) → motive_8 t | false |
UInt8.toUInt16_eq_mod_256_iff | Init.Data.UInt.Lemmas | ∀ (a : UInt8) (b : UInt16), a.toUInt16 = b % 256 ↔ a = b.toUInt8 | true |
Nat.toArray_rco_succ_right_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, m ≤ n → (m...n + 1).toArray = (m...n).toArray.push n | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_flatMap.match_1_2 | Init.Data.Vector.Lemmas | ∀ {α : Type u_2} {β : Type u_1} {m n : ℕ} {f : α → Vector β m} {b : β} {xs : Vector α n}
(motive : (∃ xs_1, (∃ a ∈ xs, f a = xs_1) ∧ b ∈ xs_1) → Prop) (x : ∃ xs_1, (∃ a ∈ xs, f a = xs_1) ∧ b ∈ xs_1),
(∀ (a : α) (h₁ : a ∈ xs) (h₂ : b ∈ f a), motive ⋯) → motive x | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.ediv_le_ediv_iff_of_dvd_of_neg_of_pos._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a < b → (a = b) = False | false |
CategoryTheory.Grp.instFullMonForget₂Mon | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
(CategoryTheory.Grp.forget₂Mon C).Full | true |
CategoryTheory.Grothendieck.eqToHom_eq | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (hF : X = Y),
CategoryTheory.eqToHom hF = { base := CategoryTheory.eqToHom ⋯, fiber := CategoryTheory.eqToHom ⋯ } | true |
Nat.zero_dvd._simp_1 | Init.Data.Nat.Dvd | ∀ {n : ℕ}, (0 ∣ n) = (n = 0) | false |
CategoryTheory.MonoidalCategory.tensorLeftTensor_hom_app | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
(CategoryTheory.MonoidalCategory.tensorLeftTensor X Y).hom.app Z =
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom | true |
CategoryTheory.Bicategory.InducedBicategory.forget_mapComp_inv | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c),
(CategoryTheory.Bicategory.InducedBicategory.forget.mapComp f g).inv =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f.hom g.hom) | true |
WeierstrassCurve.φ_four | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R),
W.φ 4 =
Polynomial.C Polynomial.X * Polynomial.C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 -
Polynomial.C W.preΨ₄ * W.ψ₂ ^ 4 * Polynomial.C W.Ψ₃ +
Polynomial.C W.Ψ₃ ^ 4 | true |
Relation.reflexive_reflGen | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop}, Reflexive (Relation.ReflGen r) | true |
OrderMonoidHomClass.toOrderAddMonoidHom | Mathlib.Algebra.Order.Hom.Monoid | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : AddZeroClass α] →
[inst_3 : AddZeroClass β] →
[inst_4 : FunLike F α β] → [OrderHomClass F α β] → [AddMonoidHomClass F α β] → F → α →+o β | true |
_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.UniqueProds.toTwoUniqueProds_of_group._simp_1_3 | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
Substring.Raw.Legacy.foldr | Batteries.Data.String.Legacy | {α : Type u} → (Char → α → α) → α → Substring.Raw → α | true |
Fin.insertNthEquiv.eq_1 | Mathlib.MeasureTheory.Integral.Pi | ∀ {n : ℕ} (α : Fin (n + 1) → Type u) (p : Fin (n + 1)),
Fin.insertNthEquiv α p =
{ toFun := fun f => p.insertNth f.1 f.2, invFun := fun f => (f p, p.removeNth f), left_inv := ⋯, right_inv := ⋯ } | true |
CategoryTheory.Functor.WellOrderInductionData.Extension.match_1 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {J : Type u_1} →
[inst : LinearOrder J] →
(i : J) →
(motive : { x // x ∈ Set.Iio i }ᵒᵖ → Sort u_2) →
(x : { x // x ∈ Set.Iio i }ᵒᵖ) → ((k : J) → (hk : k ∈ Set.Iio i) → motive (Opposite.op ⟨k, hk⟩)) → motive x | false |
Lean.Meta.Grind.Arith.Linear.State._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.Linear.Types | SizeOf Lean.Meta.Grind.Arith.Linear.State | false |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents_hom_φ | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Limits.FormalCoproduct C} (e : X.I ≃ Y.I)
(h : (i : X.I) → X.obj i ≅ Y.obj (e i)) (i : X.I),
(CategoryTheory.Limits.FormalCoproduct.isoOfComponents e h).hom.φ i = (h i).hom | true |
ContinuousAlternatingMap.le_of_opNNNorm_le | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] {f : E [⋀^ι]→L[𝕜] F} {C : NNReal},
‖f‖₊ ≤ C → ∀ (m : ι → E), ‖f m‖₊ ≤ C * ∏ i, ‖m i‖₊ | true |
Order.PFilter.principal_le_iff | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : Preorder P] {x : P} {F : Order.PFilter P}, Order.PFilter.principal x ≤ F ↔ x ∈ F | true |
Ideal.smul_mem_pointwise_smul_iff | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M}
{S : Ideal R} {x : R}, a • x ∈ a • S ↔ x ∈ S | true |
Option.getD.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (dflt x : α), (some x).getD dflt = x | true |
CategoryTheory.MonoOver.congr._proof_2 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (e : C ≌ D) (f : CategoryTheory.MonoOver (e.functor.obj X)),
CategoryTheory.Mono
((CategoryTheory.Over.post e.inverse).obj ((CategoryTheory.MonoOver.forget (e.functor.obj X)).obj f)).hom | false |
Lean.Meta.Grind.SplitSource.beta.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Grind.SplitSource.beta e) = 1 + sizeOf e | true |
CategoryTheory.LaxFunctor.PseudoCore._sizeOf_1 | Mathlib.CategoryTheory.Bicategory.Functor.Lax | {B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F : CategoryTheory.LaxFunctor B C} → [SizeOf B] → [SizeOf C] → F.PseudoCore → ℕ | false |
MulActionHom | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} → (M → N) → (X : Type u_5) → [SMul M X] → (Y : Type u_6) → [SMul N Y] → Type (max u_5 u_6) | true |
Function.Embedding.optionEmbeddingEquiv_apply_fst | Mathlib.Logic.Embedding.Set | ∀ (α : Type u_1) (β : Type u_2) (f : Option α ↪ β),
((Function.Embedding.optionEmbeddingEquiv α β) f).fst = Function.Embedding.some.trans f | true |
Right.add_pos | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddRightStrictMono α] {a b : α},
0 < a → 0 < b → 0 < a + b | true |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.map_genWeightSpace_eq_of_injective._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] [inst_7 : LieRingModule L M'] {f : M →ₗ⁅R,L⁆ M'} {N : LieSubmodule R L M} (m' : M'),
(m' ∈ LieSubmodule.map f N) = ∃ m ∈ N, f m = m' | false |
CategoryTheory.Limits.WalkingPair.equivBool._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ (b : Bool),
(fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
((fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left) b) =
b | false |
_private.Mathlib.Topology.Order.HullKernel.0.PrimitiveSpectrum.isTopologicalBasis_relativeLower._simp_1_3 | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u} (a : α), {a}.Finite = True | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.