name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.MonoidalCategory.DayFunctor.equiv | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(V : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
CategoryTheory.MonoidalCategory.DayFunctor C V ≌ CategoryT... | true |
Std.DHashMap.Internal.Raw₀.getKey?ₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Internal.Raw₀ α β → α → Option α | true |
Nat.instLinearOrder._proof_3 | Mathlib.Data.Nat.Basic | ∀ (a b : ℕ), compare a b = compareOfLessAndEq a b | false |
NumberField.mixedEmbedding.volume_fundamentalDomain_stdBasis | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
MeasureTheory.volume (ZSpan.fundamentalDomain (NumberField.mixedEmbedding.stdBasis K)) = 1 | true |
LinearMap.mk₂'ₛₗ._proof_5 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_2} [inst : Semiring R] {S : Type u_4} [inst_1 : Semiring S] {S₂ : Type u_6} [inst_2 : Semiring S₂]
{M : Type u_3} {N : Type u_5} {P : Type u_1} [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module S N] [inst_8 : Module S₂ P] (σ₁₂ : S →... | false |
CategoryTheory.GradedObject.comapEq._proof_6 | Mathlib.CategoryTheory.GradedObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C] {β γ : Type u_1} {f g : β → γ} (h : f = g)
⦃X Y : CategoryTheory.GradedObject γ C⦄ (f_1 : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.comap C g).map f_1) fun b =>
CategoryTheory.eqToHom ⋯) =
CategoryTheory.Categor... | false |
AddCon.correspondence.eq_1 | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Add M] {c : AddCon M},
AddCon.correspondence =
{ toFun := fun d => AddCon.mapOfSurjective c.mkAddHom ⋯ ⋯,
invFun := fun d => ⟨AddCon.comap AddCon.toQuotient ⋯ d, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_rel_iff' := ⋯ } | true |
Std.ExtHashSet.mem_of_get_eq | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (m : Std.ExtHashSet α) {k v : α} {w : k ∈ m},
m.get k w = v → k ∈ m | true |
jacobiSum_mul_jacobiSum_inv | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {F' : Type u_2} [inst : Fintype F] [inst_1 : Field F] [inst_2 : Field F'],
ringChar F' ≠ ringChar F →
∀ {χ φ : MulChar F F'}, χ ≠ 1 → φ ≠ 1 → χ * φ ≠ 1 → jacobiSum χ φ * jacobiSum χ⁻¹ φ⁻¹ = ↑(Fintype.card F) | true |
_private.Std.Data.ExtTreeMap.Lemmas.0.Std.ExtTreeMap.ext_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t t' : Std.ExtTreeMap α β cmp}, t = t' ↔ t.inner = t'.inner | true |
Std.ExtHashMap.mem_insertMany_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} {ρ : Type w}
[inst : ForIn Id ρ (α × β)] [inst_1 : EquivBEq α] [inst_2 : LawfulHashable α] {l : ρ} {k : α},
k ∈ m → k ∈ m.insertMany l | true |
CategoryTheory.Triangulated.AbelianSubcategory.isColimitCokernelCofork._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_4} {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | false |
DirectSum.Decomposition.decompose'_eq | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {M : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike σ M]
[inst_3 : AddSubmonoidClass σ M] (ℳ : ι → σ) [inst_4 : DirectSum.Decomposition ℳ],
DirectSum.Decomposition.decompose' = ⇑(DirectSum.decompose ℳ) | true |
Std.TreeMap.Raw.WF.out | Std.Data.TreeMap.Raw.Basic | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}, t.WF → t.inner.WF | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.exists_le_iSup_basicOpen_and_smul_eq_smul_and_eq_const._simp_1_5 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) | false |
Std.Sat.AIG.RelabelNat.State | Std.Sat.AIG.RelabelNat | (α : Type) → [DecidableEq α] → [Hashable α] → Array (Std.Sat.AIG.Decl α) → ℕ → Type | true |
FiniteGaloisIntermediateField.instMin | Mathlib.FieldTheory.Galois.GaloisClosure | {k : Type u_1} →
{K : Type u_2} →
[inst : Field k] → [inst_1 : Field K] → [inst_2 : Algebra k K] → Min (FiniteGaloisIntermediateField k K) | true |
LocallyConstant.instCommRing._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommRing Y], ⇑0 = ⇑0 | false |
_private.Mathlib.CategoryTheory.Monoidal.Mon_.0.CategoryTheory.Functor.FullyFaithful.isAddMonHom_preimage._simp_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj X] {Z... | false |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.ofNatCode.match_1.eq_2 | Mathlib.Computability.PartrecCode | ∀ (motive : Bool → Bool → Sort u_1) (h_1 : Unit → motive false false) (h_2 : Unit → motive false true)
(h_3 : Unit → motive true false) (h_4 : Unit → motive true true),
(match false, true with
| false, false => h_1 ()
| false, true => h_2 ()
| true, false => h_3 ()
| true, true => h_4 ()) =
h_2 ... | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.assignElimVars.go._sunfold | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | List Int.Linear.Var → Lean.Meta.Grind.GoalM Unit | false |
CategoryTheory.PreZeroHypercover.isLimitSigmaOfIsColimitEquiv._proof_1 | Mathlib.CategoryTheory.Sites.CoproductSheafCondition | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
{c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c) [(E.sigmaOfIsColimit hc).HasPullbacks],
CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.Cofan.IsColimit.desc hc E.f)... | false |
MeasureTheory.Integrable.neg' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, MeasureTheory.Integrable f μ → MeasureTheory.Integrable (fun i => -f i) μ | true |
Algebra.IsPushout.mk._flat_ctor | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
{S' : Type u_7} [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' ... | false |
CategoryTheory.Limits.WidePullbackCone.IsLimit.lift.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_1} {X : C} {Y : ι → C} {f : (i : ι) → Y i ⟶ X}
{s : CategoryTheory.Limits.WidePullbackCone f} (hs hs_1 : CategoryTheory.Limits.IsLimit s),
hs = hs_1 →
∀ {W : C} (b b_1 : W ⟶ X) (e_b : b = b_1) (a a_1 : (i : ι) → W ⟶ Y i) (e_a : a = a_1)
... | true |
rotation._proof_2 | Mathlib.Analysis.Complex.Isometry | SMulCommClass Circle ℝ ℂ | false |
LinearMap.codRestrict.congr_simp | Mathlib.Algebra.Module.Submodule.Map | ∀ {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₂}
(p : Submodule R₂ M₂) (f f_1 : M →ₛₗ[σ₁₂] M₂) (e_f : f = f_1) (h : ∀ (c : M), f c ∈ p),
L... | true |
Lean.Compiler.LCNF.isTypeFormerType._unsafe_rec | Lean.Compiler.LCNF.Types | Lean.Expr → Bool | false |
LieSubmodule.ucs_eq_top_iff | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] (N : LieSubmodule R L M)
[inst_6 : LieModule R L M] (k : ℕ), LieSubmodule.ucs k N = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N | true |
LTSeries.last_range | Mathlib.Order.RelSeries | ∀ (n : ℕ), RelSeries.last (LTSeries.range n) = n | true |
CategoryTheory.Limits.ColimitPresentation.ofIso_diag | Mathlib.CategoryTheory.Limits.Presentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.Category.{t, w} J]
{X : C} (P : CategoryTheory.Limits.ColimitPresentation J X) {Y : C} (e : X ≅ Y), (P.ofIso e).diag = P.diag | true |
instRingPadic._proof_22 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (a : ℚ_[p]), -a + a = 0 | false |
CategoryTheory.MorphismProperty.instRespectsIsoPushouts | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C), P.pushouts.RespectsIso | true |
Sylow.instSubgroupClass | Mathlib.GroupTheory.Sylow | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], SubgroupClass (Sylow p G) G | true |
_private.Init.Data.Vector.Nat.0.Vector.sum_replicate_nat._simp_1_1 | Init.Data.Vector.Nat | ∀ {α : Type u_1} {n : ℕ} [inst : Add α] [inst_1 : Zero α] {xs : Vector α n}, xs.sum = xs.toArray.sum | false |
TestFunction.instAdd._proof_2 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n),
HasCompactSupport (⇑f + ⇑g) | false |
Pi.addMonoid | Mathlib.Algebra.Group.Pi.Basic | {I : Type u} → {f : I → Type v₁} → [(i : I) → AddMonoid (f i)] → AddMonoid ((i : I) → f i) | true |
List.findIdxNth_le_length._simp_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {n : ℕ} {xs : List α}, (List.findIdxNth p xs n ≤ xs.length) = True | false |
QuaternionAlgebra.equivTuple._proof_3 | Mathlib.Algebra.Quaternion | NeZero (3 + 1) | false |
PiTensorProduct.instCommRing._proof_2 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : ι → Type u_3} [inst : CommRing R] [inst_1 : (i : ι) → CommRing (A i)]
[inst_2 : (i : ι) → Algebra R (A i)] (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | false |
CategoryTheory.Limits.colimit.homIso' | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
(W : C) →
ULift.{u₁, v} (CategoryTheory.Limits.colimit F ⟶... | true |
ConGen.Rel.trans | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] {r : M → M → Prop} {x y z : M}, ConGen.Rel r x y → ConGen.Rel r y z → ConGen.Rel r x z | true |
Ideal.Quotient.exists_inv | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_3} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] [hI : I.IsMaximal] {a : R ⧸ I},
a ≠ 0 → ∃ b, a * b = 1 | true |
Array.mem_push_of_mem | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {x : α} (y : α), x ∈ xs → x ∈ xs.push y | true |
IsCyclotomicExtension.ring_of_integers' | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] [NeZero n] [inst_2 : CharZero K] [IsCyclotomicExtension {n} ℚ K],
IsCyclotomicExtension {n} ℤ (NumberField.RingOfIntegers K) | true |
Subsemigroup.iSup_induction | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {ι : Sort u_1} {M : Type u_2} [inst : Mul M] (S : ι → Subsemigroup M) {C : M → Prop} {x₁ : M},
x₁ ∈ ⨆ i, S i → (∀ (i : ι), ∀ x₂ ∈ S i, C x₂) → (∀ (x y : M), C x → C y → C (x * y)) → C x₁ | true |
Std.DTreeMap.Raw.le_maxKeyD_of_contains | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | true |
CompHausLike.isoOfHomeo_hom_hom_hom_apply | Mathlib.Topology.Category.CompHausLike.Basic | ∀ {P : TopCat → Prop} {X Y : CompHausLike P} (f : ↑X.toTop ≃ₜ ↑Y.toTop)
(a : ↑((CompHausLike.compHausLikeToTop P).obj X)), (TopCat.Hom.hom (CompHausLike.isoOfHomeo f).hom.hom) a = f a | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.DefaultConsumers.forIn'_eq_forIn'.match_1_2 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {β : Type u_2} {γ : Type u_1} {init : γ} (Pl : β → γ → ForInStep γ → Prop) (out : β)
(motive : Subtype (Pl out init) → Prop) (forInStep : Subtype (Pl out init)),
(∀ (a : γ) (h : Pl out init (ForInStep.yield a)), motive ⟨ForInStep.yield a, h⟩) →
(∀ (a : γ) (h : Pl out init (ForInStep.done a)), motive ⟨ForInSte... | false |
Int.instShiftLeft_mathlib | Mathlib.Data.Int.Bitwise | ShiftLeft ℤ | true |
CategoryTheory.Precoverage.equivPreZeroHypercoverFamily._proof_3 | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (P : CategoryTheory.PreZeroHypercoverFamily C),
(fun K => K.preZeroHypercoverFamily) ((fun P => P.precoverage) P) = P | false |
Lean.Options.instEmptyCollection | Lean.Data.Options | EmptyCollection Lean.Options | true |
FreeMagma.noConfusion | Mathlib.Algebra.Free | {P : Sort u_1} →
{α : Type u} →
{t : FreeMagma α} → {α' : Type u} → {t' : FreeMagma α'} → α = α' → t ≍ t' → FreeMagma.noConfusionType P t t' | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.blacklistInsertion.match_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) →
((pre : Lean.Name) → motive (pre.str "inj")) →
((pre : Lean.Name) → motive (pre.str "injEq")) →
((pre : Lean.Name) → motive (pre.str "sizeOf_spec")) → ((x : Lean.Name) → motive x) → motive declName | false |
CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_obj | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left}
{d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d)
(a : CategoryTheory.Limits.Fork (I.fstPiMapOf... | true |
CategoryTheory.StructuredArrow.preIsoMap₂._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {B : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} B] (S : D)
(F : CategoryTheory.Functor B C) (G : CategoryTheory.Functor C D) (x : CategoryTheory.StructuredArrow S (F.comp G)),
... | false |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.allCombinations.go | Lean.Elab.PreDefinition.Structural.FindRecArg | {α : Type u_1} → Array (Array α) → ℕ → Array α → Array (Array α) | true |
BoundedContinuousFunction.toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | {α : Type u_1} →
{E : Type u_2} →
{m0 : MeasurableSpace α} →
(p : ENNReal) →
(μ : MeasureTheory.Measure α) →
[inst : TopologicalSpace α] →
[BorelSpace α] →
[inst_2 : NormedAddCommGroup E] →
[SecondCountableTopologyEither α E] →
[M... | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.reduceLeQ.match_1 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(iM' : Q(PartialOrder «$M»)) →
(iM'' : Q(PosMulStrictMono «$M»)) →
(iM''' : Q(PosMulReflectLE «$M»)) →
(iM'''' : Q(ZeroLEOneClass «$M»)) →
(l₁ l₂ : Mathlib.Tactic.FieldSimp.qNF M) →
... | false |
List.length.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (head : α) (tail : List α), (head :: tail).length = tail.length + 1 | true |
CategoryTheory.ShiftedHom.opEquiv'_add_symm | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] {X Y : C}
(n m a a' a'' : ℤ) (ha' : n + a = a') (ha'' : m + a' = a'')
(x :
Opposite.op ((CategoryTheory.shiftFunctor C a).obj Y) ⟶
(CategoryTheory.shiftFunctor Cᵒᵖ (m + n)).obj (Opposite.op X)),
(Catego... | true |
Set.wellFoundedOn_singleton._simp_1 | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {a : α}, {a}.WellFoundedOn r = True | false |
Lean.Compiler.LCNF.Code.jmp.inj | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} {fvarId : Lean.FVarId} {args : Array (Lean.Compiler.LCNF.Arg pu)}
{fvarId_1 : Lean.FVarId} {args_1 : Array (Lean.Compiler.LCNF.Arg pu)},
Lean.Compiler.LCNF.Code.jmp fvarId args = Lean.Compiler.LCNF.Code.jmp fvarId_1 args_1 →
fvarId = fvarId_1 ∧ args = args_1 | true |
_private.Mathlib.ModelTheory.Equivalence.0.FirstOrder.Language.Theory.Iff.imp._simp_1_4 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {φ ψ : L.BoundedFormula α l}
{v : α → M} {xs : Fin l → M}, (φ.imp ψ).Realize v xs = (φ.Realize v xs → ψ.Realize v xs) | false |
Std.TreeMap.unitOfList_cons | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {hd : α} {tl : List α},
Std.TreeMap.unitOfList (hd :: tl) cmp = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | true |
Array.filter_flatMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {g : α → Array β} {f : β → Bool},
Array.filter f (Array.flatMap g xs) = Array.flatMap (fun a => Array.filter f (g a)) xs | true |
_private.Mathlib.Algebra.DualNumber.0.DualNumber.range_lift._simp_1_3 | Mathlib.Algebra.DualNumber | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type w'} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : B →ₐ[R] C), Subalgebra.map g f.range = (g.comp f).range | false |
_private.Mathlib.Probability.Independence.Kernel.IndepFun.0.ProbabilityTheory.Kernel.iIndepFun.indepFun_finset._simp_1_6 | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
_private.Lean.Meta.Hint.0.Lean.Meta.Hint.readableDiff.maxDiff | Lean.Meta.Hint | String → String → Array (Lean.Diff.Action × String) | true |
PiTensorProduct.reindex_refl | 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)],
PiTensorProduct.reindex R s (Equiv.refl ι) = LinearEquiv.refl R (PiTensorProduct R fun i => s i) | true |
_private.Mathlib.AlgebraicGeometry.AffineSpace.0.AlgebraicGeometry.AffineSpace.SpecIso_inv_over._simp_1_2 | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {R S T : CommRingCat} (f : R ⟶ S) (g : S ⟶ T),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map g) (AlgebraicGeometry.Spec.map f) =
AlgebraicGeometry.Spec.map (CategoryTheory.CategoryStruct.comp f g) | false |
PrimeSpectrum.basicOpen_eq_zeroLocus_of_isIdempotentElem | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommRing R] (e : R),
IsIdempotentElem e → ↑(PrimeSpectrum.basicOpen e) = PrimeSpectrum.zeroLocus {1 - e} | true |
Real.rpow_mul_natCast | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ) (n : ℕ), x ^ (y * ↑n) = (x ^ y) ^ n | true |
Seminorm.smul_closedBall_preimage | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(p : Seminorm 𝕜 E) (y : E) (r : ℝ) (a : 𝕜),
a ≠ 0 → (fun x => a • x) ⁻¹' p.closedBall y r = p.closedBall (a⁻¹ • y) (r / ‖a‖) | true |
CategoryTheory.Functor.instLaxBraidedMonMapMon.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : CategoryTheory.SymmetricCategory C]
[inst_5 : CategoryTheory.... | true |
Set.pairwise_disjoint_Ico_add_intCast | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (a : α),
Pairwise (Function.onFun Disjoint fun n => Set.Ico (a + ↑n) (a + ↑n + 1)) | true |
Group.FG.out | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} {inst : Group G} [self : Group.FG G], ⊤.FG | true |
PresheafOfModules.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} {f g : M₁ ⟶ M₂}, f = g ↔ ∀ (X : Cᵒᵖ), f.app X = g.app X | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.withFields.go.match_17 | Lean.Elab.Structure | (motive : Option Lean.Elab.Command.Structure.StructFieldInfo → Sort u_1) →
(__do_lift : Option Lean.Elab.Command.Structure.StructFieldInfo) →
(Unit → motive none) →
((info : Lean.Elab.Command.Structure.StructFieldInfo) → motive (some info)) → motive __do_lift | false |
AffineMap.coe_one | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1], ⇑1 = id | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.all_dual.match_1_5 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : Ordnode α → Prop) (x : Ordnode α),
(∀ (a : Unit), motive Ordnode.nil) →
(∀ (size : ℕ) (_l : Ordnode α) (_x : α) (_r : Ordnode α), motive (Ordnode.node size _l _x _r)) → motive x | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc.0.CategoryTheory.Triangulated.TStructure.isLE_eTruncLT_obj_obj._simp_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {ι : Type u_1} [inst : LE ι] {a b : ι}, (WithBotTop.coe a ≤ WithBotTop.coe b) = (a ≤ b) | false |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.getUElimPos? | Lean.Meta.Match.Match | List Lean.Level → Lean.Level → Lean.MetaM (Option ℕ) | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.toArray_take_zip._simp_1_1 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] {it : Std.Iter β},
it.toArray = it.toList.toArray | false |
Multiset.chooseX._proof_2 | Mathlib.Data.Multiset.Basic | ∀ {α : Type u_1} (p : α → Prop) (l' : List α), (∃! a, a ∈ ⟦l'⟧ ∧ p a) → ∃ x ∈ l', p x | false |
instCommRingPointedContMDiffMap | Mathlib.Geometry.Manifold.DerivationBundle | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_3} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_4} →
[inst_3 : TopologicalSpace H] →
(I : ModelWithCorners 𝕜 E H) →
(M : Type u_2) →
... | true |
List.findFinIdx?_append._proof_2 | Init.Data.List.Find | ∀ {α : Type u_1} {xs ys : List α}, xs.length + ys.length = (xs ++ ys).length | false |
Matrix.linftyOpSemiNormedRing._proof_10 | Mathlib.Analysis.Matrix.Normed | ∀ {n : Type u_2} {α : Type u_1} [inst : Fintype n] [inst_1 : SeminormedRing α] [inst_2 : DecidableEq n] (n_1 : ℕ),
↑(n_1 + 1) = ↑n_1 + 1 | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.ensureNoMinIndexable | Lean.Meta.Tactic.Grind.EMatchTheorem | Bool → Lean.MetaM Unit | true |
CategoryTheory.GrpObj.tensorObj.inv_def | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : C} [inst_3 : CategoryTheory.GrpObj G]
[inst_4 : CategoryTheory.GrpObj H],
CategoryTheory.GrpObj.inv =
CategoryTheory.MonoidalCategoryStruct.tenso... | true |
InvolutiveStar.casesOn | Mathlib.Algebra.Star.Basic | {R : Type u} →
{motive : InvolutiveStar R → Sort u_1} →
(t : InvolutiveStar R) →
([toStar : Star R] →
(star_involutive : Function.Involutive star) →
motive { toStar := toStar, star_involutive := star_involutive }) →
motive t | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.getPatternFn?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.PatternArgKind → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.PatternArgKind) →
motive Lean.Meta.Grind.NormalizePattern.PatternArgKind.typeFormer →
motive Lean.Meta.Grind.NormalizePattern.PatternArgKind.relevant →
(Nat.hasNotBit 9 t.ctorIdx → motive t) →... | false |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeInitialRenameI.tacsToTacticSeq | Aesop.Script.OptimizeSyntax | {m : Type → Type} →
[Monad m] → [Lean.MonadQuotation m] → Array (Lean.TSyntax `tactic) → m (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq) | true |
Mathlib.Meta.Positivity.zpow_zero_pos | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_5} [inst : Semifield α] [inst_1 : PartialOrder α] [IsStrictOrderedRing α] (a : α), 0 < a ^ 0 | true |
_private.Mathlib.Algebra.Order.Algebra.0.Mathlib.Meta.Positivity.evalAlgebraMap._sparseCasesOn_1 | Mathlib.Algebra.Order.Algebra | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Meta.... | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_spectrum_term↑ₐ_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | false |
Lean.Meta.map1MetaM | Lean.Meta.Basic | {m : Type → Type u_1} →
{β : Sort u_2} →
[MonadControlT Lean.MetaM m] →
[Monad m] → ({α : Type} → (β → Lean.MetaM α) → Lean.MetaM α) → {α : Type} → (β → m α) → m α | true |
differentiableWithinAt_comp_add_left | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E),
DifferentiableWithinAt 𝕜 (fun x => f (a + x)) s x ↔ DifferentiableWi... | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.StainData.mk._flat_ctor | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.Stained✝ →
Lean.Syntax → Lean.Elab.ContextInfo → Lean.MetavarContext → List Lean.MVarId → Mathlib.Linter.Flexible.StainData✝ | false |
Lean.Grind.instFieldRat._proof_7 | Init.GrindInstances.Ring.Rat | ∀ (i : ℤ), ↑(-i) = -↑i | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.