tasksource/leandojo huggingface dataset:
Theorem: FiniteDimensional.eq_of_le_of_finrank_le
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← LinearEquiv.finrank_eq (Submodule.comapSubtypeEquivOfLe hle)] at hd
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
S₁ S₂ : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S₂ }
hle : S₁ ≤ S₂
hd : finrank K { x // x ∈ S₂ } ≤ finrank K { x // x ∈ S₁ }
⊢ S₁ = S₂

tactic: exact le_antisymm hle (Submodule.comap_subtype_eq_top.1
  (eq_top_of_finrank_eq (le_antisymm (comap (Submodule.subtype S₂) S₁).finrank_le hd)))
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
S₁ S₂ : Submodule K V
inst✝ : FiniteDimensional K { x // x ∈ S₂ }
hle : S₁ ≤ S₂
hd : finrank K { x // x ∈ S₂ } ≤ finrank K { x // x ∈ comap (Submodule.subtype S₂) S₁ }
⊢ S₁ = S₂
Theorem: AffineIsometryEquiv.symm_constVSub
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: ext
state_before: 𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.1896593
V₂ : Type ?u.1896596
V₃ : Type ?u.1896599
V₄ : Type ?u.1896602
P₁ : Type ?u.1896605
P : Type u_2
P₂ : Type ?u.1896611
P₃ : Type ?u.1896614
P₄ : Type ?u.1896617
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.1897141
inst✝ : TopologicalSpace α
p : P
⊢ symm (constVSub 𝕜 p) = trans (LinearIsometryEquiv.toAffineIsometryEquiv (LinearIsometryEquiv.neg 𝕜)) (vaddConst 𝕜 p)

tactic: rfl
state_before: case h
𝕜 : Type u_3
V : Type u_1
V₁ : Type ?u.1896593
V₂ : Type ?u.1896596
V₃ : Type ?u.1896599
V₄ : Type ?u.1896602
P₁ : Type ?u.1896605
P : Type u_2
P₂ : Type ?u.1896611
P₃ : Type ?u.1896614
P₄ : Type ?u.1896617
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.1897141
inst✝ : TopologicalSpace α
p : P
x✝ : V
⊢ ↑(symm (constVSub 𝕜 p)) x✝ =
    ↑(trans (LinearIsometryEquiv.toAffineIsometryEquiv (LinearIsometryEquiv.neg 𝕜)) (vaddConst 𝕜 p)) x✝
Theorem: Polynomial.bernoulli_eval_one
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

tactic: simp only [bernoulli, eval_finset_sum]
state_before: n : ℕ
⊢ eval 1 (bernoulli n) = bernoulli' n

tactic: simp only [← succ_eq_add_one, sum_range_succ, mul_one, cast_one, choose_self,
  (_root_.bernoulli _).mul_comm, sum_bernoulli, one_pow, mul_one, eval_C, eval_monomial, one_mul]
state_before: n : ℕ
⊢ ∑ i in range (n + 1), eval 1 (↑(monomial (n - i)) (_root_.bernoulli i * ↑(Nat.choose n i))) = bernoulli' n

tactic: by_cases h : n = 1
state_before: n : ℕ
⊢ (if n = 1 then 1 else 0) + _root_.bernoulli n = bernoulli' n

tactic: simp [h]
state_before: case pos
n : ℕ
h : n = 1
⊢ (if n = 1 then 1 else 0) + _root_.bernoulli n = bernoulli' n

tactic: norm_num
state_before: case pos
n : ℕ
h : n = 1
⊢ 1 + -1 / 2 = 2⁻¹

tactic: simp [h]
state_before: case neg
n : ℕ
h : ¬n = 1
⊢ (if n = 1 then 1 else 0) + _root_.bernoulli n = bernoulli' n

tactic: exact bernoulli_eq_bernoulli'_of_ne_one h
state_before: case neg
n : ℕ
h : ¬n = 1
⊢ _root_.bernoulli n = bernoulli' n
Theorem: nhds_basis_closeds
File: Mathlib/Topology/Basic.lean

tactic: simp only [isOpen_compl_iff, mem_compl_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t✝ : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
a : α
t : Set α
⊢ (∃ x, (a ∈ xᶜ ∧ IsOpen (xᶜ)) ∧ xᶜ ⊆ t) ↔ ∃ i, (¬a ∈ i ∧ IsClosed i) ∧ iᶜ ⊆ t
Theorem: TopCat.mono_iff_injective
File: Mathlib/Topology/Category/TopCat/EpiMono.lean

tactic: suffices Mono f ↔ Mono ((forget TopCat).map f) by
  rw [this, CategoryTheory.mono_iff_injective]
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Mono f ↔ Function.Injective ((forget TopCat).map f)

tactic: constructor
state_before: X Y : TopCat
f : X ⟶ Y
⊢ Mono f ↔ Mono ((forget TopCat).map f)

tactic: rw [this, CategoryTheory.mono_iff_injective]
state_before: X Y : TopCat
f : X ⟶ Y
this : Mono f ↔ Mono ((forget TopCat).map f)
⊢ Mono f ↔ Function.Injective ((forget TopCat).map f)

tactic: intro
state_before: case mp
X Y : TopCat
f : X ⟶ Y
⊢ Mono f → Mono ((forget TopCat).map f)

tactic: infer_instance
state_before: case mp
X Y : TopCat
f : X ⟶ Y
a✝ : Mono f
⊢ Mono ((forget TopCat).map f)

tactic: apply Functor.mono_of_mono_map
state_before: case mpr
X Y : TopCat
f : X ⟶ Y
⊢ Mono ((forget TopCat).map f) → Mono f
Theorem: Filter.Tendsto.isCompact_insert_range_of_cofinite
File: Mathlib/Topology/SubsetProperties.lean

tactic: letI : TopologicalSpace ι := ⊥
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.50005
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : ι → α
a : α
hf : Tendsto f cofinite (𝓝 a)
⊢ IsCompact (insert a (range f))

tactic: haveI h : DiscreteTopology ι := ⟨rfl⟩
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.50005
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : ι → α
a : α
hf : Tendsto f cofinite (𝓝 a)
this : TopologicalSpace ι := ⊥
⊢ IsCompact (insert a (range f))

tactic: rw [← cocompact_eq_cofinite ι] at hf
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.50005
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : ι → α
a : α
hf : Tendsto f cofinite (𝓝 a)
this : TopologicalSpace ι := ⊥
h : DiscreteTopology ι
⊢ IsCompact (insert a (range f))

tactic: exact hf.isCompact_insert_range_of_cocompact continuous_of_discreteTopology
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type ?u.50005
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
f : ι → α
a : α
this : TopologicalSpace ι := ⊥
hf : Tendsto f (cocompact ι) (𝓝 a)
h : DiscreteTopology ι
⊢ IsCompact (insert a (range f))
Theorem: List.insertNth_removeNth_of_ge
File: Mathlib/Data/List/Basic.lean

tactic: simp [removeNth, insertNth]
state_before: ι : Type ?u.113338
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
as : List α
x✝¹ : 0 < length (head✝ :: as)
x✝ : 0 ≤ 0
⊢ insertNth 0 a (removeNth (head✝ :: as) 0) = removeNth (insertNth (0 + 1) a (head✝ :: as)) 0
Theorem: Cardinal.mk_univ_quaternionAlgebra_of_infinite
File: Mathlib/Algebra/Quaternion.lean

tactic: rw [mk_univ_quaternionAlgebra, pow_four]
state_before: R : Type u_1
c₁ c₂ : R
inst✝ : Infinite R
⊢ (#↑Set.univ) = (#R)
Theorem: Equiv.exists_unique_congr
File: Mathlib/Logic/Equiv/Defs.lean

tactic: constructor
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
⊢ (∃! x, p x) ↔ ∃! y, q y

tactic: rintro ⟨a, ha₁, ha₂⟩
state_before: case mp
α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
⊢ (∃! x, p x) → ∃! y, q y

tactic: exact ⟨f a, h.1 ha₁, fun b hb => f.symm_apply_eq.1 (ha₂ (f.symm b) (h.2 (by simpa using hb)))⟩
state_before: case mp.intro.intro
α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
a : α
ha₁ : p a
ha₂ : ∀ (y : α), (fun x => p x) y → y = a
⊢ ∃! y, q y

tactic: simpa using hb
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
a : α
ha₁ : p a
ha₂ : ∀ (y : α), (fun x => p x) y → y = a
b : β
hb : (fun y => q y) b
⊢ q (↑f (↑f.symm b))

tactic: rintro ⟨b, hb₁, hb₂⟩
state_before: case mpr
α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
⊢ (∃! y, q y) → ∃! x, p x

tactic: exact ⟨f.symm b, h.2 (by simpa using hb₁), fun y hy => (eq_symm_apply f).2 (hb₂ _ (h.1 hy))⟩
state_before: case mpr.intro.intro
α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
b : β
hb₁ : q b
hb₂ : ∀ (y : β), (fun y => q y) y → y = b
⊢ ∃! x, p x

tactic: simpa using hb₁
state_before: α : Sort u
β : Sort v
γ : Sort w
p : α → Prop
q : β → Prop
f : α ≃ β
h : ∀ {x : α}, p x ↔ q (↑f x)
b : β
hb₁ : q b
hb₂ : ∀ (y : β), (fun y => q y) y → y = b
⊢ q (↑f (↑f.symm b))
Theorem: Fin.sigma_eq_of_eq_comp_cast
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: dsimp only at hi
state_before: m n : ℕ
α : Type u_1
ai : ℕ
a : Fin ai → α
bi : ℕ
b : Fin bi → α
hi : { fst := ai, snd := a }.fst = { fst := bi, snd := b }.fst
h : { fst := ai, snd := a }.snd = { fst := bi, snd := b }.snd ∘ ↑(cast hi)
⊢ { fst := ai, snd := a } = { fst := bi, snd := b }

tactic: subst hi
state_before: m n : ℕ
α : Type u_1
ai : ℕ
a : Fin ai → α
bi : ℕ
b : Fin bi → α
hi : ai = bi
h : { fst := ai, snd := a }.snd = { fst := bi, snd := b }.snd ∘ ↑(cast hi)
⊢ { fst := ai, snd := a } = { fst := bi, snd := b }

tactic: simpa using h
state_before: m n : ℕ
α : Type u_1
ai : ℕ
a b : Fin ai → α
h : { fst := ai, snd := a }.snd = { fst := ai, snd := b }.snd ∘ ↑(cast (_ : ai = ai))
⊢ { fst := ai, snd := a } = { fst := ai, snd := b }
Theorem: CategoryTheory.isCoseparating_op_iff
File: Mathlib/CategoryTheory/Generator.lean

tactic: refine' ⟨fun h𝒢 X Y f g hfg => _, fun h𝒢 X Y f g hfg => _⟩
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set C
⊢ IsCoseparating (Set.op 𝒢) ↔ IsSeparating 𝒢

tactic: refine' Quiver.Hom.op_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.unop_inj _)
state_before: case refine'_1
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set C
h𝒢 : IsCoseparating (Set.op 𝒢)
X Y : C
f g : X ⟶ Y
hfg : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ f = g

tactic: simpa only [unop_comp, Quiver.Hom.unop_op] using hfg _ (Set.mem_op.1 hG) _
state_before: case refine'_1
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set C
h𝒢 : IsCoseparating (Set.op 𝒢)
X Y : C
f g : X ⟶ Y
hfg : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
G : Cᵒᵖ
hG : G ∈ Set.op 𝒢
h : X.op ⟶ G
⊢ (f.op ≫ h).unop = (g.op ≫ h).unop

tactic: refine' Quiver.Hom.unop_inj (h𝒢 _ _ fun G hG h => Quiver.Hom.op_inj _)
state_before: case refine'_2
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ (G : Cᵒᵖ), G ∈ Set.op 𝒢 → ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
⊢ f = g

tactic: simpa only [op_comp, Quiver.Hom.op_unop] using hfg _ (Set.op_mem_op.2 hG) _
state_before: case refine'_2
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : Cᵒᵖ
f g : X ⟶ Y
hfg : ∀ (G : Cᵒᵖ), G ∈ Set.op 𝒢 → ∀ (h : Y ⟶ G), f ≫ h = g ≫ h
G : C
hG : G ∈ 𝒢
h : G ⟶ Y.unop
⊢ (h ≫ f.unop).op = (h ≫ g.unop).op
Theorem: Matrix.isUnit_det_transpose
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [det_transpose]
state_before: l : Type ?u.97236
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ IsUnit (det Aᵀ)

tactic: exact h
state_before: l : Type ?u.97236
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ IsUnit (det A)
Theorem: Int.ediv_le_self
File: Std/Data/Int/DivMod.lean

tactic: have := Int.le_trans le_natAbs (ofNat_le.2 <| natAbs_div_le_natAbs a b)
state_before: a b : Int
Ha : 0 ≤ a
⊢ a / b ≤ a

tactic: rwa [natAbs_of_nonneg Ha] at this
state_before: a b : Int
Ha : 0 ≤ a
this : a / b ≤ ↑(natAbs a)
⊢ a / b ≤ a
Theorem: ZMod.valMinAbs_natCast_of_le_half
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases n
state_before: n a : ℕ
ha : a ≤ n / 2
⊢ valMinAbs ↑a = ↑a

tactic: simp
state_before: case zero
a : ℕ
ha : a ≤ Nat.zero / 2
⊢ valMinAbs ↑a = ↑a

tactic: simp [valMinAbs_def_pos, val_nat_cast, Nat.mod_eq_of_lt (ha.trans_lt <| Nat.div_lt_self' _ 0),
  ha]
state_before: case succ
a n✝ : ℕ
ha : a ≤ Nat.succ n✝ / 2
⊢ valMinAbs ↑a = ↑a
Theorem: inner_map_polarization
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [map_add, map_sub, inner_add_left, inner_add_right, LinearMap.map_smul, inner_smul_left,
  inner_smul_right, Complex.conj_I, ← pow_two, Complex.I_sq, inner_sub_left, inner_sub_right,
  mul_add, ← mul_assoc, mul_neg, neg_neg, sub_neg_eq_add, one_mul, neg_one_mul, mul_sub, sub_sub]
state_before: 𝕜 : Type ?u.2712404
E : Type ?u.2712407
F : Type ?u.2712410
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
x y : V
⊢ inner (↑T y) x =
    (inner (↑T (x + y)) (x + y) - inner (↑T (x - y)) (x - y) +
          Complex.I * inner (↑T (x + Complex.I • y)) (x + Complex.I • y) -
        Complex.I * inner (↑T (x - Complex.I • y)) (x - Complex.I • y)) /
      4

tactic: ring
state_before: 𝕜 : Type ?u.2712404
E : Type ?u.2712407
F : Type ?u.2712410
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℂ V
T : V →ₗ[ℂ] V
x y : V
⊢ inner (↑T y) x =
    (inner (↑T x) x + inner (↑T y) x + (inner (↑T x) y + inner (↑T y) y) -
            (inner (↑T x) x - (inner (↑T y) x + (inner (↑T x) y - inner (↑T y) y))) +
          (Complex.I * inner (↑T x) x + inner (↑T y) x + (-inner (↑T x) y + Complex.I * inner (↑T y) y)) -
        (Complex.I * inner (↑T x) x - (inner (↑T y) x + (-inner (↑T x) y - Complex.I * inner (↑T y) y)))) /
      4
Theorem: Real.tendsto_pow_log_div_mul_add_atTop
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: filter_upwards [eventually_gt_atTop (0 : ℝ)] with x hx using by simp [exp_log hx]
state_before: x y a b : ℝ
n : ℕ
ha : a ≠ 0
⊢ (fun x => x ^ n / (a * exp x + b)) ∘ log =ᶠ[atTop] fun x => log x ^ n / (a * x + b)

tactic: simp [exp_log hx]
state_before: x✝ y a b : ℝ
n : ℕ
ha : a ≠ 0
x : ℝ
hx : 0 < x
⊢ ((fun x => x ^ n / (a * exp x + b)) ∘ log) x = log x ^ n / (a * x + b)
Theorem: circleMap_mem_sphere'
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

tactic: simp
state_before: E : Type ?u.9896
inst✝ : NormedAddCommGroup E
c : ℂ
R θ : ℝ
⊢ circleMap c R θ ∈ sphere c (Abs.abs R)
Theorem: List.zipWith_eq_zipWithTR
File: Std/Data/List/Basic.lean

tactic: funext α β γ f as bs
state_before: ⊢ @zipWith = @zipWithTR

tactic: let rec go : ∀ as bs acc, zipWithTR.go f as bs acc = acc.data ++ as.zipWith f bs
  | [], _, acc | _::_, [], acc => by simp [zipWithTR.go, zipWith]
  | a::as, b::bs, acc => by simp [zipWithTR.go, zipWith, go as bs]
state_before: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → β → γ
as : List α
bs : List β
⊢ zipWith f as bs = zipWithTR f as bs

tactic: exact (go as bs #[]).symm
state_before: case h.h.h.h.h.h
α : Type u_3
β : Type u_2
γ : Type u_1
f : α → β → γ
as : List α
bs : List β
⊢ zipWith f as bs = zipWithTR f as bs

tactic: simp [zipWithTR.go, zipWith]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → β → γ
as : List α
bs : List β
head✝ : α
tail✝ : List α
acc : Array γ
⊢ zipWithTR.go f (head✝ :: tail✝) [] acc = acc.data ++ zipWith f (head✝ :: tail✝) []

tactic: simp [zipWithTR.go, zipWith, go as bs]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
f : α → β → γ
as✝ : List α
bs✝ : List β
a : α
as : List α
b : β
bs : List β
acc : Array γ
⊢ zipWithTR.go f (a :: as) (b :: bs) acc = acc.data ++ zipWith f (a :: as) (b :: bs)
Theorem: Int.div_one
File: Std/Data/Int/DivMod.lean

tactic: simp [Int.div, neg_ofNat_succ]
state_before: n : Nat
⊢ div -[n+1] 1 = -[n+1]
Theorem: LinearMap.lTensor_pow
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: have h := TensorProduct.map_pow (id : M →ₗ[R] M) f n
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.1304029
inst✝¹³ : Monoid R'
R'' : Type ?u.1304035
inst✝¹² : Semiring R''
M : Type u_3
N : Type u_2
P : Type ?u.1304047
Q : Type ?u.1304050
S : Type ?u.1304053
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f : N →ₗ[R] N
n : ℕ
⊢ lTensor M f ^ n = lTensor M (f ^ n)

tactic: rwa [id_pow] at h
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.1304029
inst✝¹³ : Monoid R'
R'' : Type ?u.1304035
inst✝¹² : Semiring R''
M : Type u_3
N : Type u_2
P : Type ?u.1304047
Q : Type ?u.1304050
S : Type ?u.1304053
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f : N →ₗ[R] N
n : ℕ
h : map id f ^ n = map (id ^ n) (f ^ n)
⊢ lTensor M f ^ n = lTensor M (f ^ n)
Theorem: NonUnitalRingHom.comp_zero
File: Mathlib/Algebra/Hom/Ring.lean

tactic: ext
state_before: F : Type ?u.33482
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
⊢ comp g 0 = 0

tactic: simp
state_before: case a
F : Type ?u.33482
α : Type u_3
β : Type u_1
γ : Type u_2
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
x✝ : α
⊢ ↑(comp g 0) x✝ = ↑0 x✝
Theorem: Asymptotics.isTheta_norm_right
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simp [IsTheta]
state_before: α : Type u_1
β : Type ?u.22376
E : Type u_2
F : Type ?u.22382
G : Type ?u.22385
E' : Type ?u.22388
F' : Type u_3
G' : Type ?u.22394
E'' : Type ?u.22397
F'' : Type ?u.22400
G'' : Type ?u.22403
R : Type ?u.22406
R' : Type ?u.22409
𝕜 : Type ?u.22412
𝕜' : Type ?u.22415
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
⊢ (f =Θ[l] fun x => ‖g' x‖) ↔ f =Θ[l] g'
Theorem: Pi.mulSupport_mulSingle_disjoint
File: Mathlib/Algebra/Support.lean

tactic: rw [mulSupport_mulSingle_of_ne hb, mulSupport_mulSingle_of_ne hb', disjoint_singleton]
state_before: A : Type u_2
B : Type u_1
inst✝¹ : DecidableEq A
inst✝ : One B
a : A
b b' : B
hb : b ≠ 1
hb' : b' ≠ 1
i j : A
⊢ Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j
Theorem: ContDiffBump.support_eq
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp only [toFun, support_comp_eq_preimage, ContDiffBumpBase.support _ _ f.one_lt_rOut_div_rIn]
state_before: E : Type u_1
X : Type ?u.84106
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
⊢ Function.support ↑f = ball c f.rOut

tactic: ext x
state_before: E : Type u_1
X : Type ?u.84106
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x : E
n : ℕ∞
⊢ (fun x => f.rIn⁻¹ • (x - c)) ⁻¹' ball 0 (f.rOut / f.rIn) = ball c f.rOut

tactic: simp only [mem_ball_iff_norm, sub_zero, norm_smul, mem_preimage, norm_eq_abs, abs_inv,
  abs_of_pos f.rIn_pos, ← div_eq_inv_mul, div_lt_div_right f.rIn_pos]
state_before: case h
E : Type u_1
X : Type ?u.84106
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f : ContDiffBump c
x✝ : E
n : ℕ∞
x : E
⊢ x ∈ (fun x => f.rIn⁻¹ • (x - c)) ⁻¹' ball 0 (f.rOut / f.rIn) ↔ x ∈ ball c f.rOut
Theorem: gauge_lt_one_subset_self
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: rw [gauge_lt_eq absorbs]
state_before: 𝕜 : Type ?u.71418
E : Type u_1
F : Type ?u.71424
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
⊢ {x | gauge s x < 1} ⊆ s

tactic: refine' Set.iUnion₂_subset fun r hr _ => _
state_before: 𝕜 : Type ?u.71418
E : Type u_1
F : Type ?u.71424
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
⊢ (⋃ (r : ℝ) (_ : r ∈ Ioo 0 1), r • s) ⊆ s

tactic: rintro ⟨y, hy, rfl⟩
state_before: 𝕜 : Type ?u.71418
E : Type u_1
F : Type ?u.71424
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
r : ℝ
hr : r ∈ Ioo 0 1
x✝ : E
⊢ x✝ ∈ r • s → x✝ ∈ s

tactic: exact hs.smul_mem_of_zero_mem h₀ hy (Ioo_subset_Icc_self hr)
state_before: case intro.intro
𝕜 : Type ?u.71418
E : Type u_1
F : Type ?u.71424
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
hs : Convex ℝ s
h₀ : 0 ∈ s
absorbs : Absorbent ℝ s
r : ℝ
hr : r ∈ Ioo 0 1
y : E
hy : y ∈ s
⊢ (fun x => r • x) y ∈ s
Theorem: Filter.HasBasis.nhds
File: Mathlib/Topology/Filter.lean

tactic: rw [nhds_eq]
state_before: ι : Sort u_2
α : Type u_1
β : Type ?u.5424
X : Type ?u.5427
Y : Type ?u.5430
l : Filter α
p : ι → Prop
s : ι → Set α
h : HasBasis l p s
⊢ HasBasis (𝓝 l) p fun i => Iic (𝓟 (s i))

tactic: exact h.lift' monotone_principal.Iic
state_before: ι : Sort u_2
α : Type u_1
β : Type ?u.5424
X : Type ?u.5427
Y : Type ?u.5430
l : Filter α
p : ι → Prop
s : ι → Set α
h : HasBasis l p s
⊢ HasBasis (Filter.lift' l (Iic ∘ 𝓟)) p fun i => Iic (𝓟 (s i))
Theorem: wellFounded_iff_wellFounded_subrel
File: Mathlib/Order/InitialSeg.lean

tactic: refine'
  ⟨fun wf b => ⟨fun b' => ((PrincipalSeg.ofElement _ b).acc b').mpr (wf.apply b')⟩, fun wf =>
    ⟨fun b => Acc.intro _ fun b' hb' => _⟩⟩
state_before: α : Type ?u.65547
β✝ : Type ?u.65550
γ : Type ?u.65553
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_1
s : β → β → Prop
inst✝ : IsTrans β s
⊢ WellFounded s ↔ ∀ (b : β), WellFounded (Subrel s {b' | s b' b})

tactic: let f := PrincipalSeg.ofElement s b
state_before: α : Type ?u.65547
β✝ : Type ?u.65550
γ : Type ?u.65553
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_1
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
⊢ Acc s b'

tactic: obtain ⟨b', rfl⟩ := f.down.mp ((PrincipalSeg.ofElement_top s b).symm ▸ hb' : s b' f.top)
state_before: α : Type ?u.65547
β✝ : Type ?u.65550
γ : Type ?u.65553
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_1
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b b' : β
hb' : s b' b
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
⊢ Acc s b'

tactic: exact (f.acc b').mp ((wf b).apply b')
state_before: case intro
α : Type ?u.65547
β✝ : Type ?u.65550
γ : Type ?u.65553
r : α → α → Prop
s✝ : β✝ → β✝ → Prop
t : γ → γ → Prop
β : Type u_1
s : β → β → Prop
inst✝ : IsTrans β s
wf : ∀ (b : β), WellFounded (Subrel s {b' | s b' b})
b : β
f : Subrel s {b_1 | s b_1 b} ≺i s := PrincipalSeg.ofElement s b
b' : ↑{b_1 | s b_1 b}
hb' : s (↑f.toRelEmbedding b') b
⊢ Acc s (↑f.toRelEmbedding b')