tasksource/leandojo huggingface dataset:
Theorem: Module.End.eigenspace_div
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [div_eq_mul_inv, mul_comm]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ eigenspace f (a / b) = eigenspace f (b⁻¹ * a)

tactic: rw [eigenspace]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ eigenspace f (b⁻¹ * a) = LinearMap.ker (f - (b⁻¹ * a) • LinearMap.id)

tactic: rfl
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ LinearMap.ker (f - ↑(algebraMap K (End K V)) (b⁻¹ * a)) = LinearMap.ker (f - (b⁻¹ * a) • LinearMap.id)

tactic: rw [smul_smul]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ LinearMap.ker (f - (b⁻¹ * a) • LinearMap.id) = LinearMap.ker (f - b⁻¹ • a • LinearMap.id)

tactic: rw [LinearMap.ker_smul _ b hb]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ LinearMap.ker (f - b⁻¹ • ↑(algebraMap K (End K V)) a) = LinearMap.ker (b • (f - b⁻¹ • ↑(algebraMap K (End K V)) a))

tactic: rw [smul_sub, smul_inv_smul₀ hb]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End K V
a b : K
hb : b ≠ 0
⊢ LinearMap.ker (b • (f - b⁻¹ • ↑(algebraMap K (End K V)) a)) = LinearMap.ker (b • f - ↑(algebraMap K (End K V)) a)
Theorem: ENNReal.lintegral_mul_eq_zero_of_lintegral_rpow_eq_zero
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: rw [← @lintegral_zero_fun α _ μ]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
⊢ (∫⁻ (a : α), (f * g) a ∂μ) = 0

tactic: refine' lintegral_congr_ae _
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
⊢ (∫⁻ (a : α), (f * g) a ∂μ) = lintegral μ 0

tactic: suffices h_mul_zero : f * g =ᵐ[μ] 0 * g
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
⊢ (fun a => (f * g) a) =ᵐ[μ] fun a => OfNat.ofNat 0 a

tactic: have hf_eq_zero : f =ᵐ[μ] 0 := ae_eq_zero_of_lintegral_rpow_eq_zero hp0 hf hf_zero
state_before: case h_mul_zero
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
⊢ f * g =ᵐ[μ] 0 * g

tactic: exact hf_eq_zero.mul (ae_eq_refl g)
state_before: case h_mul_zero
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
hf_eq_zero : f =ᵐ[μ] 0
⊢ f * g =ᵐ[μ] 0 * g

tactic: rwa [MulZeroClass.zero_mul] at h_mul_zero
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0 : 0 ≤ p
f g : α → ℝ≥0∞
hf : AEMeasurable f
hf_zero : (∫⁻ (a : α), f a ^ p ∂μ) = 0
h_mul_zero : f * g =ᵐ[μ] 0 * g
⊢ (fun a => (f * g) a) =ᵐ[μ] fun a => OfNat.ofNat 0 a
Theorem: BilinForm.flip_flip_aux
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: ext A
state_before: R : Type u_2
M : Type u_3
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
R₁ : Type ?u.194705
M₁ : Type ?u.194708
inst✝¹² : Ring R₁
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.195320
inst✝⁹ : CommSemiring R₂
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R₂ M₂
R₃ : Type ?u.195507
M₃ : Type ?u.195510
inst✝⁶ : CommRing R₃
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : Module R₃ M₃
V : Type ?u.196098
K : Type ?u.196101
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
D : BilinForm R M
D₁ : BilinForm R₁ M₁
inst✝ : Algebra R₂ R
A : BilinForm R M
⊢ ↑(flipHomAux R₂) (↑(flipHomAux R₂) A) = A

tactic: simp [flipHomAux]
state_before: case H
R : Type u_2
M : Type u_3
inst✝¹⁵ : Semiring R
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
R₁ : Type ?u.194705
M₁ : Type ?u.194708
inst✝¹² : Ring R₁
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R₁ M₁
R₂ : Type u_1
M₂ : Type ?u.195320
inst✝⁹ : CommSemiring R₂
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R₂ M₂
R₃ : Type ?u.195507
M₃ : Type ?u.195510
inst✝⁶ : CommRing R₃
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : Module R₃ M₃
V : Type ?u.196098
K : Type ?u.196101
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
D : BilinForm R M
D₁ : BilinForm R₁ M₁
inst✝ : Algebra R₂ R
A✝ : BilinForm R M
A : M
⊢ ∀ (y : M), bilin (↑(flipHomAux R₂) (↑(flipHomAux R₂) A✝)) A y = bilin A✝ A y
Theorem: CategoryTheory.Iso.trans_assoc
File: Mathlib/CategoryTheory/Iso.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
X Y Z Z' : C
α : X ≅ Y
β : Y ≅ Z
γ : Z ≅ Z'
⊢ (α ≪≫ β) ≪≫ γ = α ≪≫ β ≪≫ γ

tactic: simp only [trans_hom, Category.assoc]
state_before: case w
C : Type u
inst✝ : Category C
X Y Z Z' : C
α : X ≅ Y
β : Y ≅ Z
γ : Z ≅ Z'
⊢ ((α ≪≫ β) ≪≫ γ).hom = (α ≪≫ β ≪≫ γ).hom
Theorem: isTotallyDisconnected_of_isTotallySeparated
File: Mathlib/Topology/Connected.lean

tactic: intro t hts ht x x_in y y_in
state_before: α : Type u
β : Type v
ι : Type ?u.134712
π : ι → Type ?u.134717
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : IsTotallySeparated s
⊢ IsTotallyDisconnected s

tactic: by_contra h
state_before: α : Type u
β : Type v
ι : Type ?u.134712
π : ι → Type ?u.134717
inst✝ : TopologicalSpace α
s✝ t✝ u v s : Set α
H : IsTotallySeparated s
t : Set α
hts : t ⊆ s
ht : IsPreconnected t
x : α
x_in : x ∈ t
y : α
y_in : y ∈ t
⊢ x = y

tactic: obtain
  ⟨u : Set α, v : Set α, hu : IsOpen u, hv : IsOpen v, hxu : x ∈ u, hyv : y ∈ v, hs : s ⊆ u ∪ v,
    huv⟩ :=
  H x (hts x_in) y (hts y_in) h
state_before: α : Type u
β : Type v
ι : Type ?u.134712
π : ι → Type ?u.134717
inst✝ : TopologicalSpace α
s✝ t✝ u v s : Set α
H : IsTotallySeparated s
t : Set α
hts : t ⊆ s
ht : IsPreconnected t
x : α
x_in : x ∈ t
y : α
y_in : y ∈ t
h : ¬x = y
⊢ False

tactic: refine' (ht _ _ hu hv (hts.trans hs) ⟨x, x_in, hxu⟩ ⟨y, y_in, hyv⟩).ne_empty _
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.134712
π : ι → Type ?u.134717
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ s : Set α
H : IsTotallySeparated s
t : Set α
hts : t ⊆ s
ht : IsPreconnected t
x : α
x_in : x ∈ t
y : α
y_in : y ∈ t
h : ¬x = y
u v : Set α
hu : IsOpen u
hv : IsOpen v
hxu : x ∈ u
hyv : y ∈ v
hs : s ⊆ u ∪ v
huv : Disjoint u v
⊢ False

tactic: rw [huv.inter_eq, inter_empty]
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
ι : Type ?u.134712
π : ι → Type ?u.134717
inst✝ : TopologicalSpace α
s✝ t✝ u✝ v✝ s : Set α
H : IsTotallySeparated s
t : Set α
hts : t ⊆ s
ht : IsPreconnected t
x : α
x_in : x ∈ t
y : α
y_in : y ∈ t
h : ¬x = y
u v : Set α
hu : IsOpen u
hv : IsOpen v
hxu : x ∈ u
hyv : y ∈ v
hs : s ⊆ u ∪ v
huv : Disjoint u v
⊢ t ∩ (u ∩ v) = ∅
Theorem: Mathlib.Meta.NormNum.isRat_inv_pos
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro ⟨_, rfl⟩
state_before: α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
a : α
n d : ℕ
⊢ IsRat a (Int.ofNat (Nat.succ n)) d → IsRat a⁻¹ (Int.ofNat d) (Nat.succ n)

tactic: have := invertibleOfNonzero (α := α) (Nat.cast_ne_zero.2 (Nat.succ_ne_zero n))
state_before: case mk
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
⊢ IsRat (↑(Int.ofNat (Nat.succ n)) * ⅟↑d)⁻¹ (Int.ofNat d) (Nat.succ n)

tactic: refine ⟨this, by simp⟩
state_before: case mk
α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑(Nat.succ n)
⊢ IsRat (↑(Int.ofNat (Nat.succ n)) * ⅟↑d)⁻¹ (Int.ofNat d) (Nat.succ n)

tactic: simp
state_before: α : Type u_1
inst✝¹ : DivisionRing α
inst✝ : CharZero α
n d : ℕ
inv✝ : Invertible ↑d
this : Invertible ↑(Nat.succ n)
⊢ (↑(Int.ofNat (Nat.succ n)) * ⅟↑d)⁻¹ = ↑(Int.ofNat d) * ⅟↑(Nat.succ n)
Theorem: List.get_append_right
File: src/lean/Init/Data/List/BasicAux.lean

tactic: induction as generalizing i with
| nil => trivial
| cons a as ih =>
  cases i with simp [get, Nat.succ_sub_succ] <;> simp_arith [Nat.succ_sub_succ] at h
  | succ i => apply ih; simp_arith [h]
state_before: α : Type u_1
i : Nat
as bs : List α
h : ¬i < length as
h' : i < length (as ++ bs)
h'' : i - length as < length bs
⊢ get (as ++ bs) { val := i, isLt := h' } = get bs { val := i - length as, isLt := h'' }

tactic: trivial
state_before: case nil
α : Type u_1
bs : List α
i : Nat
h : ¬i < length []
h' : i < length ([] ++ bs)
h'' : i - length [] < length bs
⊢ get ([] ++ bs) { val := i, isLt := h' } = get bs { val := i - length [], isLt := h'' }

tactic: cases i with simp [get, Nat.succ_sub_succ] <;> simp_arith [Nat.succ_sub_succ] at h
| succ i => apply ih; simp_arith [h]
state_before: case cons
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat},
    ¬i < length as →
      ∀ {h' : i < length (as ++ bs)} {h'' : i - length as < length bs},
        get (as ++ bs) { val := i, isLt := h' } = get bs { val := i - length as, isLt := h'' }
i : Nat
h : ¬i < length (a :: as)
h' : i < length (a :: as ++ bs)
h'' : i - length (a :: as) < length bs
⊢ get (a :: as ++ bs) { val := i, isLt := h' } = get bs { val := i - length (a :: as), isLt := h'' }

tactic: apply ih
state_before: case cons.succ
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat},
    ¬i < length as →
      ∀ {h' : i < length (as ++ bs)} {h'' : i - length as < length bs},
        get (as ++ bs) { val := i, isLt := h' } = get bs { val := i - length as, isLt := h'' }
i : Nat
h' : Nat.succ i < length (a :: as ++ bs)
h'' : Nat.succ i - length (a :: as) < length bs
h : length as ≤ i
⊢ get (as ++ bs) { val := i, isLt := (_ : Nat.succ i ≤ length (List.append as bs)) } =
    get bs { val := i - length as, isLt := (_ : i - length as < length bs) }

tactic: simp_arith [h]
state_before: case cons.succ.h
α : Type u_1
bs : List α
a : α
as : List α
ih :
  ∀ {i : Nat},
    ¬i < length as →
      ∀ {h' : i < length (as ++ bs)} {h'' : i - length as < length bs},
        get (as ++ bs) { val := i, isLt := h' } = get bs { val := i - length as, isLt := h'' }
i : Nat
h' : Nat.succ i < length (a :: as ++ bs)
h'' : Nat.succ i - length (a :: as) < length bs
h : length as ≤ i
⊢ ¬i < length as
Theorem: goldConj_sq
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [goldenConj, ← sub_eq_zero]
state_before: ⊢ ψ ^ 2 = ψ + 1

tactic: ring_nf
state_before: ⊢ ((1 - sqrt 5) / 2) ^ 2 - ((1 - sqrt 5) / 2 + 1) = 0

tactic: rw [Real.sq_sqrt] <;> norm_num
state_before: ⊢ sqrt 5 ^ 2 * (↑(Int.ofNat 1) / ↑4) + ↑(Int.negOfNat 5) * (↑(Int.ofNat 1) / ↑4) = 0
Theorem: ULift.down_injective
File: Mathlib/Logic/Basic.lean

tactic: congr
state_before: α : Type u_1
a b : α
x✝ : { down := a }.down = { down := b }.down
⊢ { down := a } = { down := b }
Theorem: MeasureTheory.measure_trim_toMeasurable_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rwa [@measure_toMeasurable _ m]
state_before: α : Type u_1
β : Type ?u.3498066
γ : Type ?u.3498069
δ : Type ?u.3498072
ι : Type ?u.3498075
R : Type ?u.3498078
R' : Type ?u.3498081
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
hm : m ≤ m0
hs : ↑↑(trim μ hm) s = 0
⊢ ↑↑(trim μ hm) (toMeasurable (trim μ hm) s) = 0
Theorem: LocalHomeomorph.extend_target_mem_nhdsWithin
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [← LocalEquiv.image_source_eq_target, ← map_extend_nhds f I hy]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.139594
M' : Type ?u.139597
H' : Type ?u.139600
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
y : M
hy : y ∈ f.source
⊢ (extend f I).target ∈ 𝓝[range ↑I] ↑(extend f I) y

tactic: exact image_mem_map (extend_source_mem_nhds _ _ hy)
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.139594
M' : Type ?u.139597
H' : Type ?u.139600
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
y : M
hy : y ∈ f.source
⊢ ↑(extend f I) '' (extend f I).source ∈ map (↑(extend f I)) (𝓝 y)
Theorem: LinearRecurrence.is_sol_mkSol
File: Mathlib/Algebra/LinearRecurrence.lean

tactic: intro n
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
⊢ IsSolution E (mkSol E init)

tactic: rw [mkSol]
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ mkSol E init (n + E.order) = ∑ i : Fin E.order, coeffs E i * mkSol E init (n + ↑i)

tactic: simp
state_before: α : Type u_1
inst✝ : CommSemiring α
E : LinearRecurrence α
init : Fin E.order → α
n : ℕ
⊢ (if h : n + E.order < E.order then init { val := n + E.order, isLt := h }
    else
      ∑ k : Fin E.order,
        let_fun x := (_ : n + E.order - E.order + ↑k < n + E.order);
        coeffs E k * mkSol E init (n + E.order - E.order + ↑k)) =
    ∑ i : Fin E.order, coeffs E i * mkSol E init (n + ↑i)
Theorem: Cycle.forall_eq_of_chain
File: Mathlib/Data/List/Cycle.lean

tactic: rw [chain_iff_pairwise] at hs
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : Chain r s
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b

tactic: exact antisymm (hs a ha b hb) (hs b hb a ha)
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsAntisymm α r
hs : ∀ (a : α), a ∈ s → ∀ (b : α), b ∈ s → r a b
a b : α
ha : a ∈ s
hb : b ∈ s
⊢ a = b
Theorem: Polynomial.mirror_mirror
File: Mathlib/Data/Polynomial/Mirror.lean

tactic: rw [coeff_mirror, coeff_mirror, mirror_natDegree, mirror_natTrailingDegree, revAt_invol]
state_before: R : Type u_1
inst✝ : Semiring R
p q : R[X]
n : ℕ
⊢ coeff (mirror (mirror p)) n = coeff p n
Theorem: skewAdjoint.smul_mem
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: rw [mem_iff, star_smul, star_trivial, mem_iff.mp h, smul_neg r]
state_before: R : Type u_1
A : Type u_2
inst✝⁶ : Star R
inst✝⁵ : TrivialStar R
inst✝⁴ : AddCommGroup A
inst✝³ : StarAddMonoid A
inst✝² : Monoid R
inst✝¹ : DistribMulAction R A
inst✝ : StarModule R A
r : R
x : A
h : x ∈ skewAdjoint A
⊢ r • x ∈ skewAdjoint A
Theorem: Filter.map_map₂_distrib
File: Mathlib/Order/Filter/NAry.lean

tactic: simp_rw [map_map₂, map₂_map_left, map₂_map_right, h_distrib]
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type u_6
γ : Type u_2
γ' : Type ?u.39560
δ : Type u_1
δ' : Type ?u.39566
ε : Type ?u.39569
ε' : Type ?u.39572
m : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
n : γ → δ
m' : α' → β' → δ
n₁ : α → α'
n₂ : β → β'
h_distrib : ∀ (a : α) (b : β), n (m a b) = m' (n₁ a) (n₂ b)
⊢ map n (map₂ m f g) = map₂ m' (map n₁ f) (map n₂ g)
Theorem: Lists.to_ofList
File: Mathlib/SetTheory/Lists.lean

tactic: simp [ofList, of']
state_before: α : Type u_1
l : List (Lists α)
⊢ toList (ofList l) = l
Theorem: FractionalIdeal.spanSingleton_zero
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: ext
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1321354
inst✝³ : CommRing R₁
K : Type ?u.1321360
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
⊢ spanSingleton S 0 = 0

tactic: simp [Submodule.mem_span_singleton, eq_comm]
state_before: case a
R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1321354
inst✝³ : CommRing R₁
K : Type ?u.1321360
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x✝ : P
⊢ x✝ ∈ spanSingleton S 0 ↔ x✝ ∈ 0
Theorem: CategoryTheory.eq_of_comp_left_eq
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert w (𝟙 Y) <;>
aesop
state_before: C : Type u
inst✝ : Category C
X Y Z : C
f g : X ⟶ Y
w : ∀ {Z : C} (h : Y ⟶ Z), f ≫ h = g ≫ h
⊢ f = g
Theorem: PadicInt.mul_inv
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: have hk : k ≠ 0 := fun h' => zero_ne_one' ℚ_[p] (by simp [h'] at h)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖{ val := k, property := property✝ }‖ = 1
⊢ { val := k, property := property✝ } * inv { val := k, property := property✝ } = 1

tactic: unfold PadicInt.inv
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖{ val := k, property := property✝ }‖ = 1
hk : k ≠ 0
⊢ { val := k, property := property✝ } * inv { val := k, property := property✝ } = 1

tactic: rw [norm_eq_padic_norm] at h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖{ val := k, property := property✝ }‖ = 1
hk : k ≠ 0
⊢ ({ val := k, property := property✝ } *
      match { val := k, property := property✝ } with
      | { val := k, property := property } => if h : ‖k‖ = 1 then { val := k⁻¹, property := (_ : ‖k⁻¹‖ ≤ 1) } else 0) =
    1

tactic: dsimp only
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖k‖ = 1
hk : k ≠ 0
⊢ ({ val := k, property := property✝ } *
      match { val := k, property := property✝ } with
      | { val := k, property := property } => if h : ‖k‖ = 1 then { val := k⁻¹, property := (_ : ‖k⁻¹‖ ≤ 1) } else 0) =
    1

tactic: rw [dif_pos h]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖k‖ = 1
hk : k ≠ 0
⊢ ({ val := k, property := property✝ } * if h : ‖k‖ = 1 then { val := k⁻¹, property := (_ : ‖k⁻¹‖ ≤ 1) } else 0) = 1

tactic: apply Subtype.ext_iff_val.2
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖k‖ = 1
hk : k ≠ 0
⊢ { val := k, property := property✝ } * { val := k⁻¹, property := (_ : ‖k⁻¹‖ ≤ 1) } = 1

tactic: simp [mul_inv_cancel hk]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖k‖ = 1
hk : k ≠ 0
⊢ ↑({ val := k, property := property✝ } * { val := k⁻¹, property := (_ : ‖k⁻¹‖ ≤ 1) }) = ↑1

tactic: simp [h'] at h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : ℚ_[p]
property✝ : ‖k‖ ≤ 1
h : ‖{ val := k, property := property✝ }‖ = 1
h' : k = 0
⊢ 0 = 1
Theorem: Nat.log_mul_base
File: Mathlib/Data/Nat/Log.lean

tactic: apply log_eq_of_pow_le_of_lt_pow <;> rw [pow_succ', mul_comm b]
state_before: b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ log b (n * b) = log b n + 1

tactic: exacts [mul_le_mul_right' (pow_log_le_self _ hn) _,
  (mul_lt_mul_right (zero_lt_one.trans hb)).2 (lt_pow_succ_log_self hb _)]
state_before: case h₁
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ b ^ log b n * b ≤ n * b

case h₂
b n : ℕ
hb : 1 < b
hn : n ≠ 0
⊢ n * b < b ^ (log b n + 1) * b
Theorem: Int.gcd_div
File: Mathlib/Data/Int/GCD.lean

tactic: rw [gcd, natAbs_ediv i k H1, natAbs_ediv j k H2]
state_before: i j k : ℤ
H1 : k ∣ i
H2 : k ∣ j
⊢ gcd (i / k) (j / k) = gcd i j / natAbs k

tactic: exact Nat.gcd_div (natAbs_dvd_natAbs.mpr H1) (natAbs_dvd_natAbs.mpr H2)
state_before: i j k : ℤ
H1 : k ∣ i
H2 : k ∣ j
⊢ Nat.gcd (natAbs i / natAbs k) (natAbs j / natAbs k) = gcd i j / natAbs k
Theorem: Set.preimage_subset_preimage_iff
File: Mathlib/Data/Set/Image.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
⊢ f ⁻¹' s ⊆ f ⁻¹' t ↔ s ⊆ t

tactic: intro h x
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
⊢ s ⊆ t → f ⁻¹' s ⊆ f ⁻¹' t

tactic: apply h
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
h : s ⊆ t
x : β
⊢ x ∈ f ⁻¹' s → x ∈ f ⁻¹' t

tactic: intro h x hx
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
⊢ f ⁻¹' s ⊆ f ⁻¹' t → s ⊆ t

tactic: rcases hs hx with ⟨y, rfl⟩
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
h : f ⁻¹' s ⊆ f ⁻¹' t
x : α
hx : x ∈ s
⊢ x ∈ t

tactic: exact h hx
state_before: case mp.intro
α : Type u_1
β : Type u_2
γ : Type ?u.77161
ι : Sort ?u.77164
ι' : Sort ?u.77167
f✝ : ι → α
s✝ t✝ s t : Set α
f : β → α
hs : s ⊆ range f
h : f ⁻¹' s ⊆ f ⁻¹' t
y : β
hx : f y ∈ s
⊢ f y ∈ t
Theorem: Submodule.map_op_pow
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [map_equiv_eq_comap_symm, map_equiv_eq_comap_symm, comap_unop_pow]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
⊢ map (↑(opLinearEquiv R)) (M ^ n) = map (↑(opLinearEquiv R)) M ^ n
Theorem: Filter.HasBasis.uniformContinuousOn_iff
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp_rw [Prod.forall, Set.inter_comm (s _), ball_mem_comm, mem_inter_iff, mem_prod, and_imp]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_2
inst✝¹ : UniformSpace α
ι' : Sort u_1
inst✝ : UniformSpace β
p : ι → Prop
s : ι → Set (α × α)
ha : HasBasis (𝓤 α) p s
q : ι' → Prop
t : ι' → Set (β × β)
hb : HasBasis (𝓤 β) q t
f : α → β
S : Set α
⊢ (∀ (ib : ι'), q ib → ∃ ia, p ia ∧ ∀ (x : α × α), x ∈ s ia ∩ S ×ˢ S → (f x.fst, f x.snd) ∈ t ib) ↔
    ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ (x : α), x ∈ S → ∀ (y : α), y ∈ S → (x, y) ∈ s j → (f x, f y) ∈ t i
Theorem: List.sum_take_map_length_lt2
File: Mathlib/Data/List/Join.lean

tactic: convert lt_of_lt_of_le (sum_take_map_length_lt1 L hi hj) (monotone_sum_take _ hi)
state_before: α : Type u_1
β : Type ?u.13935
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
⊢ sum (take i (map length L)) + j < length (join L)

tactic: have : L.length = (L.map length).length := by simp
state_before: case h.e'_4
α : Type u_1
β : Type ?u.13935
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
⊢ length (join L) = (fun i => sum (take i (map length L))) (length L)

tactic: simp [this, -length_map]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.13935
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
this : length L = length (map length L)
⊢ length (join L) = (fun i => sum (take i (map length L))) (length L)

tactic: simp
state_before: α : Type u_1
β : Type ?u.13935
L : List (List α)
i j : ℕ
hi : i < length L
hj : j < length (nthLe L i hi)
⊢ length L = length (map length L)
Theorem: WittVector.constantCoeff_wittZSMul
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type ?u.198597
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
z : ℤ
n : ℕ
⊢ ↑constantCoeff (wittZSMul p z n) = 0

tactic: simp only [smul_zero, map_zsmul, constantCoeff_X]
state_before: p : ℕ
R : Type ?u.198597
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
z : ℤ
n : ℕ
⊢ ↑constantCoeff (z • X 0) = 0