tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Groupoid.isThin_iff
File: Mathlib/CategoryTheory/Groupoid/Basic.lean

tactic: refine' ⟨fun h c => h c c, fun h c d => Subsingleton.intro fun f g => _⟩
state_before: C : Type u_1
inst✝ : Groupoid C
⊢ Quiver.IsThin C ↔ ∀ (c : C), Subsingleton (c ⟶ c)

tactic: haveI := h d
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
⊢ f = g

tactic: calc
  f = f ≫ inv g ≫ g := by simp only [inv_eq_inv, IsIso.inv_hom_id, Category.comp_id]
  _ = f ≫ inv f ≫ g := by congr 1
                          simp only [inv_eq_inv, IsIso.inv_hom_id, eq_iff_true_of_subsingleton]
  _ = g := by simp only [inv_eq_inv, IsIso.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f = g

tactic: simp only [inv_eq_inv, IsIso.inv_hom_id, Category.comp_id]
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f = f ≫ inv g ≫ g

tactic: congr 1
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f ≫ inv g ≫ g = f ≫ inv f ≫ g

tactic: simp only [inv_eq_inv, IsIso.inv_hom_id, eq_iff_true_of_subsingleton]
state_before: case e_a
C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ inv g ≫ g = inv f ≫ g

tactic: simp only [inv_eq_inv, IsIso.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Groupoid C
h : ∀ (c : C), Subsingleton (c ⟶ c)
c d : C
f g : c ⟶ d
this : Subsingleton (d ⟶ d)
⊢ f ≫ inv f ≫ g = g
Theorem: MeasureTheory.integral_indicator_const
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [integral_indicator s_meas, ← set_integral_const]
state_before: α : Type u_1
β : Type ?u.119005
E : Type u_2
F : Type ?u.119011
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
e : E
s : Set α
s_meas : MeasurableSet s
⊢ (∫ (a : α), indicator s (fun x => e) a ∂μ) = ENNReal.toReal (↑↑μ s) • e
Theorem: FractionalIdeal.mul_def
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp only [← mul_eq_mul, mul]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
⊢ I * J = { val := ↑I * ↑J, property := (_ : IsFractional S (↑I * ↑J)) }
Theorem: HomologicalComplex.boundaries_eq_bot
File: Mathlib/Algebra/Homology/Homology.lean

tactic: rw [eq_bot_iff]
state_before: ι : Type u_1
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝¹ : HasImages V
inst✝ : HasZeroObject V
j : ι
h : ¬ComplexShape.Rel c (ComplexShape.prev c j) j
⊢ boundaries C j = ⊥

tactic: refine' imageSubobject_le _ 0 _
state_before: ι : Type u_1
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝¹ : HasImages V
inst✝ : HasZeroObject V
j : ι
h : ¬ComplexShape.Rel c (ComplexShape.prev c j) j
⊢ boundaries C j ≤ ⊥

tactic: rw [C.dTo_eq_zero h, zero_comp]
state_before: ι : Type u_1
V : Type u
inst✝³ : Category V
inst✝² : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝¹ : HasImages V
inst✝ : HasZeroObject V
j : ι
h : ¬ComplexShape.Rel c (ComplexShape.prev c j) j
⊢ 0 ≫ Subobject.arrow ⊥ = dTo C j
Theorem: Asymptotics.superpolynomialDecay_iff_superpolynomialDecay_abs
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simp_rw [SuperpolynomialDecay, abs_mul, abs_pow]
state_before: α : Type u_1
β : Type u_2
l : Filter α
k f g g' : α → β
inst✝² : TopologicalSpace β
inst✝¹ : LinearOrderedCommRing β
inst✝ : OrderTopology β
⊢ (∀ (n : ℕ), Tendsto (fun a => abs (k a ^ n * f a)) l (𝓝 0)) ↔
    SuperpolynomialDecay l (fun a => abs (k a)) fun a => abs (f a)
Theorem: Subgroup.normalClosure_eq_iInf
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: infer_instance
state_before: G : Type u_1
G' : Type ?u.443612
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.443621
inst✝ : AddGroup A
s : Set G
⊢ Normal (normalClosure s)
Theorem: Primrec.option_get
File: Mathlib/Computability/Primrec.lean

tactic: intro hf
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.356695
σ : Type ?u.356698
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), Option.isSome (f a) = true
⊢ Primrec f → Primrec fun a => Option.get (f a) (_ : Option.isSome (f a) = true)

tactic: refine' (Nat.Primrec.pred.comp hf).of_eq fun n => _
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.356695
σ : Type ?u.356698
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), Option.isSome (f a) = true
hf : Primrec f
⊢ Primrec fun a => Option.get (f a) (_ : Option.isSome (f a) = true)

tactic: generalize hx : @decode α _ n = x
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.356695
σ : Type ?u.356698
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), Option.isSome (f a) = true
hf : Primrec f
n : ℕ
⊢ Nat.pred (encode (Option.map f (decode n))) =
    encode (Option.map (fun a => Option.get (f a) (_ : Option.isSome (f a) = true)) (decode n))

tactic: cases x <;> simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.356695
σ : Type ?u.356698
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
h : ∀ (a : α), Option.isSome (f a) = true
hf : Primrec f
n : ℕ
x : Option α
hx : decode n = x
⊢ Nat.pred (encode (Option.map f x)) =
    encode (Option.map (fun a => Option.get (f a) (_ : Option.isSome (f a) = true)) x)
Theorem: frontier_Ioc
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [frontier, closure_Ioc h.ne, interior_Ioc, Icc_diff_Ioo_same h.le]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderTopology α
inst✝¹ : DenselyOrdered α
a✝ b✝ : α
s : Set α
inst✝ : NoMaxOrder α
a b : α
h : a < b
⊢ frontier (Ioc a b) = {a, b}
Theorem: CategoryTheory.Limits.coprod.map_comp_inl_inr_codiag
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
X✝ Y✝ : C
inst✝ : HasColimitsOfShape (Discrete WalkingPair) C
X X' Y Y' : C
g : X ⟶ Y
g' : X' ⟶ Y'
⊢ map (g ≫ inl) (g' ≫ inr) ≫ codiag (Y ⨿ Y') = map g g'
Theorem: MeasureTheory.finStronglyMeasurable_zero
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp only [Pi.zero_apply, SimpleFunc.coe_zero, support_zero', measure_empty,
  WithTop.zero_lt_top, forall_const]
state_before: α✝ : Type ?u.236514
β✝ : Type ?u.236517
γ : Type ?u.236520
ι : Type ?u.236523
inst✝² : Countable ι
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
⊢ ∀ (n : ℕ), ↑↑μ (support ↑(OfNat.ofNat 0 n)) < ⊤
Theorem: Polynomial.isPrimitive_iff_content_eq_one
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← normalize_content, normalize_eq_one, IsPrimitive]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ IsPrimitive p ↔ content p = 1

tactic: simp_rw [← dvd_content_iff_C_dvd]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ (∀ (r : R), ↑C r ∣ p → IsUnit r) ↔ IsUnit (content p)

tactic: exact ⟨fun h => h p.content (dvd_refl p.content), fun h r hdvd => isUnit_of_dvd_unit hdvd h⟩
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ (∀ (r : R), r ∣ content p → IsUnit r) ↔ IsUnit (content p)
Theorem: nhds_left'_sup_nhds_right'
File: Mathlib/Topology/Algebra/Order/LeftRight.lean

tactic: rw [← nhdsWithin_union, Iio_union_Ioi]
state_before: α : Type u_1
β : Type ?u.3740
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : TopologicalSpace β
a : α
⊢ 𝓝[Iio a] a ⊔ 𝓝[Ioi a] a = 𝓝[{a}ᶜ] a
Theorem: Filter.lift_lift'_assoc
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [lift_principal, hh, eq_self_iff_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort ?u.37925
f f₁ f₂ : Filter α
h✝ h₁ h₂ g : Set α → Set β
h : Set β → Filter γ
hg : Monotone g
hh : Monotone h
⊢ (Filter.lift f fun s => Filter.lift (𝓟 (g s)) h) = Filter.lift f fun s => h (g s)
Theorem: List.kerase_append_right
File: Mathlib/Data/List/Sigma.lean

tactic: simp [not_or] at h
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h : ¬a ∈ keys (head✝ :: l₁)
⊢ kerase a (head✝ :: l₁ ++ l₂) = head✝ :: l₁ ++ kerase a l₂

tactic: simp [h.1, kerase_append_right h.2]
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
head✝ : Sigma β
l₁ : List (Sigma β)
l₂ : List (Sigma β)
h : ¬a = head✝.fst ∧ ¬a ∈ keys l₁
⊢ kerase a (head✝ :: l₁ ++ l₂) = head✝ :: l₁ ++ kerase a l₂
Theorem: CategoryTheory.Bicategory.pentagon_inv_inv_hom_hom_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← cancel_epi (f ◁ (α_ g h i).inv), ← cancel_mono (α_ (f ≫ g) h i).inv]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom = f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ (f ◁ (α_ g h i).inv ≫ (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom) ≫ (α_ (f ≫ g) h i).inv =
    (f ◁ (α_ g h i).inv ≫ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv) ≫ (α_ (f ≫ g) h i).inv
Theorem: AlgHom.card_of_powerBasis
File: Mathlib/FieldTheory/Separable.lean

tactic: let s := ((minpoly K pb.gen).map (algebraMap K L)).roots.toFinset
state_before: R : Type ?u.1134170
S : Type u_2
T : Type ?u.1134176
inst✝⁵ : CommRing S
K : Type u_1
L : Type u_3
F : Type ?u.1134188
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : Separable (minpoly K pb.gen)
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
⊢ Fintype.card (S →ₐ[K] L) = pb.dim

tactic: let _ := (PowerBasis.AlgHom.fintype pb : Fintype (S →ₐ[K] L))
state_before: R : Type ?u.1134170
S : Type u_2
T : Type ?u.1134176
inst✝⁵ : CommRing S
K : Type u_1
L : Type u_3
F : Type ?u.1134188
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : Separable (minpoly K pb.gen)
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
s : Finset L := Multiset.toFinset (roots (Polynomial.map (algebraMap K L) (minpoly K pb.gen)))
⊢ Fintype.card (S →ₐ[K] L) = pb.dim

tactic: rw [Fintype.card_congr pb.liftEquiv', Fintype.card_of_subtype s (fun x => Multiset.mem_toFinset),
  ← pb.natDegree_minpoly, natDegree_eq_card_roots h_splits, Multiset.toFinset_card_of_nodup]
state_before: R : Type ?u.1134170
S : Type u_2
T : Type ?u.1134176
inst✝⁵ : CommRing S
K : Type u_1
L : Type u_3
F : Type ?u.1134188
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : Separable (minpoly K pb.gen)
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
s : Finset L := Multiset.toFinset (roots (Polynomial.map (algebraMap K L) (minpoly K pb.gen)))
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ Fintype.card (S →ₐ[K] L) = pb.dim

tactic: exact nodup_roots ((separable_map (algebraMap K L)).mpr h_sep)
state_before: R : Type ?u.1134170
S : Type u_2
T : Type ?u.1134176
inst✝⁵ : CommRing S
K : Type u_1
L : Type u_3
F : Type ?u.1134188
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Field F
inst✝¹ : Algebra K S
inst✝ : Algebra K L
pb : PowerBasis K S
h_sep : Separable (minpoly K pb.gen)
h_splits : Splits (algebraMap K L) (minpoly K pb.gen)
s : Finset L := Multiset.toFinset (roots (Polynomial.map (algebraMap K L) (minpoly K pb.gen)))
x✝ : Fintype (S →ₐ[K] L) := PowerBasis.AlgHom.fintype pb
⊢ Multiset.Nodup (roots (Polynomial.map (algebraMap K L) (minpoly K pb.gen)))
Theorem: Dfinsupp.zipWith_def
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext i
state_before: ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
⊢ zipWith f hf g₁ g₂ = mk (support g₁ ∪ support g₂) fun i => f (↑i) (↑g₁ ↑i) (↑g₂ ↑i)

tactic: by_cases h1 : g₁ i ≠ 0 <;> by_cases h2 : g₂ i ≠ 0 <;> simp only [not_not, Ne.def] at h1 h2 <;>
  simp [h1, h2, hf]
state_before: case h
ι✝ : Type u
γ : Type w
β✝ : ι✝ → Type v
β₁✝ : ι✝ → Type v₁
β₂✝ : ι✝ → Type v₂
dec✝ : DecidableEq ι✝
inst✝¹⁰ : (i : ι✝) → Zero (β✝ i)
inst✝⁹ : (i : ι✝) → (x : β✝ i) → Decidable (x ≠ 0)
inst✝⁸ : (i : ι✝) → Zero (β₁✝ i)
inst✝⁷ : (i : ι✝) → Zero (β₂✝ i)
inst✝⁶ : (i : ι✝) → (x : β₁✝ i) → Decidable (x ≠ 0)
inst✝⁵ : (i : ι✝) → (x : β₂✝ i) → Decidable (x ≠ 0)
ι : Type u
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝⁴ : (i : ι) → Zero (β i)
inst✝³ : (i : ι) → Zero (β₁ i)
inst✝² : (i : ι) → Zero (β₂ i)
inst✝¹ : (i : ι) → (x : β₁ i) → Decidable (x ≠ 0)
inst✝ : (i : ι) → (x : β₂ i) → Decidable (x ≠ 0)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
g₁ : Π₀ (i : ι), β₁ i
g₂ : Π₀ (i : ι), β₂ i
i : ι
⊢ ↑(zipWith f hf g₁ g₂) i = ↑(mk (support g₁ ∪ support g₂) fun i => f (↑i) (↑g₁ ↑i) (↑g₂ ↑i)) i
Theorem: convexHull_union
File: Mathlib/Analysis/Convex/Join.lean

tactic: rw [← convexHull_convexHull_union_left, ← convexHull_convexHull_union_right]
state_before: ι : Sort ?u.132103
𝕜 : Type u_2
E : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t u : Set E
x y : E
hs : Set.Nonempty s
ht : Set.Nonempty t
⊢ ↑(convexHull 𝕜).toOrderHom (s ∪ t) = convexJoin 𝕜 (↑(convexHull 𝕜).toOrderHom s) (↑(convexHull 𝕜).toOrderHom t)

tactic: exact (convex_convexHull 𝕜 s).convexHull_union (convex_convexHull 𝕜 t) hs.convexHull ht.convexHull
state_before: ι : Sort ?u.132103
𝕜 : Type u_2
E : Type u_1
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t u : Set E
x y : E
hs : Set.Nonempty s
ht : Set.Nonempty t
⊢ ↑(convexHull 𝕜).toOrderHom (↑(convexHull 𝕜).toOrderHom s ∪ ↑(convexHull 𝕜).toOrderHom t) =
    convexJoin 𝕜 (↑(convexHull 𝕜).toOrderHom s) (↑(convexHull 𝕜).toOrderHom t)
Theorem: BilinForm.comp_id_right
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: ext
state_before: R : Type u_1
M : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type ?u.510541
M₁ : Type ?u.510544
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type ?u.511153
M₂ : Type ?u.511156
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type ?u.511343
M₃ : Type ?u.511346
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.511934
K : Type ?u.511937
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
l : M →ₗ[R] M
⊢ comp B l LinearMap.id = compLeft B l

tactic: rfl
state_before: case H
R : Type u_1
M : Type u_2
inst✝¹⁶ : Semiring R
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : Module R M
R₁ : Type ?u.510541
M₁ : Type ?u.510544
inst✝¹³ : Ring R₁
inst✝¹² : AddCommGroup M₁
inst✝¹¹ : Module R₁ M₁
R₂ : Type ?u.511153
M₂ : Type ?u.511156
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : Module R₂ M₂
R₃ : Type ?u.511343
M₃ : Type ?u.511346
inst✝⁷ : CommRing R₃
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R₃ M₃
V : Type ?u.511934
K : Type ?u.511937
inst✝⁴ : Field K
inst✝³ : AddCommGroup V
inst✝² : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M' : Type w
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
B : BilinForm R M
l : M →ₗ[R] M
x✝ y✝ : M
⊢ bilin (comp B l LinearMap.id) x✝ y✝ = bilin (compLeft B l) x✝ y✝
Theorem: Cardinal.pow_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [Nat.cast_zero, power_zero]
state_before: κ μ : Cardinal
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n : ℕ
H3 : μ = ↑n
α : Type u
H1 : ℵ₀ ≤ Quotient.mk isEquivalent α
⊢ Quotient.mk isEquivalent α ^ ↑Nat.zero < ℵ₀

tactic: exact one_lt_aleph0
state_before: κ μ : Cardinal
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n : ℕ
H3 : μ = ↑n
α : Type u
H1 : ℵ₀ ≤ Quotient.mk isEquivalent α
⊢ 1 < ℵ₀

tactic: rw [Nat.cast_succ, power_add, power_one]
state_before: κ μ : Cardinal
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n✝ : ℕ
H3 : μ = ↑n✝
α : Type u
H1 : ℵ₀ ≤ Quotient.mk isEquivalent α
n : ℕ
ih : Quotient.mk isEquivalent α ^ ↑n ≤ Quotient.mk isEquivalent α
⊢ Quotient.mk isEquivalent α ^ ↑(Nat.succ n) ≤ Quotient.mk isEquivalent α * Quotient.mk isEquivalent α

tactic: exact mul_le_mul_right' ih _
state_before: κ μ : Cardinal
H1✝ : ℵ₀ ≤ κ
H2 : μ < ℵ₀
n✝ : ℕ
H3 : μ = ↑n✝
α : Type u
H1 : ℵ₀ ≤ Quotient.mk isEquivalent α
n : ℕ
ih : Quotient.mk isEquivalent α ^ ↑n ≤ Quotient.mk isEquivalent α
⊢ Quotient.mk isEquivalent α ^ ↑n * Quotient.mk isEquivalent α ≤ Quotient.mk isEquivalent α * Quotient.mk isEquivalent α
Theorem: LinearEquiv.isUnit_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: apply isUnit_det_of_left_inverse
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ IsUnit (det (↑(toMatrix v v') ↑f))

tactic: simpa using (LinearMap.toMatrix_comp v v' v f.symm f).symm
state_before: case h
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ ?B ⬝ ↑(toMatrix v v') ↑f = 1

case B
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ Matrix ι ι R
Theorem: PFun.comp_assoc
File: Mathlib/Data/PFun.lean

tactic: simp only [comp_apply, Part.bind_comp]
state_before: α : Type u_4
β : Type u_3
γ : Type u_1
δ : Type u_2
ε : Type ?u.59338
ι : Type ?u.59341
f✝ : α →. β
f : γ →. δ
g : β →. γ
h : α →. β
x✝¹ : α
x✝ : δ
⊢ x✝ ∈ comp (comp f g) h x✝¹ ↔ x✝ ∈ comp f (comp g h) x✝¹
Theorem: Nat.Prime.factorization_self
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [hp]
state_before: p : ℕ
hp : Prime p
⊢ ↑(Nat.factorization p) p = 1
Theorem: Rat.toNNRat_div'
File: Mathlib/Data/Rat/NNRat.lean

tactic: rw [div_eq_inv_mul, div_eq_inv_mul, toNNRat_mul (inv_nonneg.2 hq), toNNRat_inv]
state_before: p q : ℚ
hq : 0 ≤ q
⊢ toNNRat (p / q) = toNNRat p / toNNRat q
Theorem: Polynomial.eval_nat_cast
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [← C_eq_nat_cast, eval_C]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
x : R
n : ℕ
⊢ eval x ↑n = ↑n
Theorem: Polynomial.reflect_monomial
File: Mathlib/Data/Polynomial/Reverse.lean

tactic: rw [← one_mul (X ^ n), ← one_mul (X ^ revAt N n), ← C_1, reflect_C_mul_X_pow]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
N n : ℕ
⊢ reflect N (X ^ n) = X ^ ↑(revAt N) n
Theorem: MeasureTheory.ofReal_toReal_ae_eq
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: filter_upwards [hf]
state_before: α : Type u_1
β : Type ?u.1005086
γ : Type ?u.1005089
δ : Type ?u.1005092
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ (fun x => ENNReal.ofReal (ENNReal.toReal (f x))) =ᵐ[μ] f

tactic: intro x hx
state_before: case h
α : Type u_1
β : Type ?u.1005086
γ : Type ?u.1005089
δ : Type ?u.1005092
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ ∀ (a : α), f a < ⊤ → ENNReal.ofReal (ENNReal.toReal (f a)) = f a

tactic: simp only [hx.ne, ofReal_toReal, Ne.def, not_false_iff]
state_before: case h
α : Type u_1
β : Type ?u.1005086
γ : Type ?u.1005089
δ : Type ?u.1005092
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
x : α
hx : f x < ⊤
⊢ ENNReal.ofReal (ENNReal.toReal (f x)) = f x
Theorem: Nat.factorization_mul
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext p
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ factorization (a * b) = factorization a + factorization b

tactic: simp only [add_apply, ← factors_count_eq, perm_iff_count.mp (perm_factors_mul ha hb) p,
  count_append]
state_before: case h
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
⊢ ↑(factorization (a * b)) p = ↑(factorization a + factorization b) p
Theorem: div_eq_of_eq_mul''
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [h]
state_before: α : Type ?u.59035
β : Type ?u.59038
G : Type u_1
inst✝ : Group G
a b c d : G
h : a = c * b
⊢ a / b = c
Theorem: List.mem_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: rw [← reverse_sublist, ← mem_sublists', sublists'_reverse,
  mem_map_of_injective reverse_injective]
state_before: α : Type u
β : Type v
γ : Type w
s t : List α
⊢ s ∈ sublists t ↔ s <+ t
Theorem: mem_closedBall_iff_norm'''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_closedBall', dist_eq_norm_div]
state_before: 𝓕 : Type ?u.95628
𝕜 : Type ?u.95631
α : Type ?u.95634
ι : Type ?u.95637
κ : Type ?u.95640
E : Type u_1
F : Type ?u.95646
G : Type ?u.95649
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ closedBall a r ↔ ‖a / b‖ ≤ r
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (PullbackCone.unop (limit.cone (cospan f.op g.op))).ι.app WalkingSpan.right = pullback.snd.unop
Theorem: Int.neg_mul_eq_mul_neg
File: Std/Data/Int/Lemmas.lean

tactic: rw [← Int.mul_add, Int.add_right_neg, Int.mul_zero]
state_before: a b : Int
⊢ a * b + a * -b = 0
Theorem: Filter.tendsto_Iic_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [atBot_Iic_eq, tendsto_comap_iff]
state_before: ι : Type ?u.336964
ι' : Type ?u.336967
α : Type u_1
β : Type u_2
γ : Type ?u.336976
inst✝ : SemilatticeInf α
a : α
f : β → ↑(Iic a)
l : Filter β
⊢ Tendsto f l atBot ↔ Tendsto (fun x => ↑(f x)) l atBot

tactic: rfl
state_before: ι : Type ?u.336964
ι' : Type ?u.336967
α : Type u_1
β : Type u_2
γ : Type ?u.336976
inst✝ : SemilatticeInf α
a : α
f : β → ↑(Iic a)
l : Filter β
⊢ Tendsto (Subtype.val ∘ f) l atBot ↔ Tendsto (fun x => ↑(f x)) l atBot