ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Rat.mul_den_dvd
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: q₁ q₂ : ℚ
⊢ (q₁ * q₂).den ∣ q₁.den * q₂.den
state_after: q₁ q₂ : ℚ
⊢ { num := q₁.num * q₂.num / ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯, reduced := ⋯ }.den ∣
    q₁.den * q₂.den
tactic: rw [mul_def, normalize_eq]
state_before: q₁ q₂ : ℚ
⊢ { num := q₁.num * q₂.num / ↑((q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den)),
        den := q₁.den * q₂.den / (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den), den_nz := ⋯, reduced := ⋯ }.den ∣
    q₁.den * q₂.den
state_after: case h
q₁ q₂ : ℚ
⊢ (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den
tactic: apply Nat.div_dvd_of_dvd
state_before: case h
q₁ q₂ : ℚ
⊢ (q₁.num * q₂.num).natAbs.gcd (q₁.den * q₂.den) ∣ q₁.den * q₂.den
state_after: no goals
tactic: apply Nat.gcd_dvd_right
Theorem: logDeriv_const_mul
File: Mathlib/Analysis/Calculus/LogDeriv.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NontriviallyNormedField 𝕜'
inst✝ : NormedAlgebra 𝕜 𝕜'
f : 𝕜 → 𝕜'
x : 𝕜
a : 𝕜'
ha : a ≠ 0
⊢ logDeriv (fun z => a * f z) x = logDeriv f x
state_after: no goals
tactic: simp only [logDeriv_apply, deriv_const_mul_field, mul_div_mul_left _ _ ha]
Theorem: IsPrimitiveRoot.zmodEquivZPowers_symm_apply_pow
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝³ : CommMonoid M
inst✝² : CommMonoid N
inst✝¹ : DivisionCommMonoid G
k l : ℕ
inst✝ : CommRing R
ζ : Rˣ
h : IsPrimitiveRoot ζ k
i : ℕ
⊢ h.zmodEquivZPowers.symm (Additive.ofMul ⟨ζ ^ i, ⋯⟩) = ↑i
state_after: no goals
tactic: rw [← h.zmodEquivZPowers.symm_apply_apply i, zmodEquivZPowers_apply_coe_nat]
Theorem: Nat.card_eq_one_iff_exists
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
⊢ Nat.card α = 1 ↔ ∃ x, ∀ (y : α), y = x
state_after: α : Type u_1
β : Type u_2
⊢ Subsingleton α ∧ Nonempty α ↔ ∃ x, ∀ (y : α), y = x
tactic: rw [card_eq_one_iff_unique]
state_before: α : Type u_1
β : Type u_2
⊢ Subsingleton α ∧ Nonempty α ↔ ∃ x, ∀ (y : α), y = x
state_after: no goals
tactic: exact ⟨fun ⟨s, ⟨a⟩⟩ ↦ ⟨a, fun x ↦ s.elim x a⟩, fun ⟨x, h⟩ ↦ ⟨subsingleton_of_forall_eq x h, ⟨x⟩⟩⟩
Theorem: MeasureTheory.ComplexMeasure.integrable_rnDeriv
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
c✝ c : ComplexMeasure α
μ : Measure α
⊢ Integrable (c.rnDeriv μ) μ
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
c✝ c : ComplexMeasure α
μ : Measure α
⊢ Memℒp (fun x => RCLike.re (c.rnDeriv μ x)) 1 μ ∧ Memℒp (fun x => RCLike.im (c.rnDeriv μ x)) 1 μ
tactic: rw [← memℒp_one_iff_integrable, ← memℒp_re_im_iff]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
c✝ c : ComplexMeasure α
μ : Measure α
⊢ Memℒp (fun x => RCLike.re (c.rnDeriv μ x)) 1 μ ∧ Memℒp (fun x => RCLike.im (c.rnDeriv μ x)) 1 μ
state_after: no goals
tactic: exact
    ⟨memℒp_one_iff_integrable.2 (SignedMeasure.integrable_rnDeriv _ _),
      memℒp_one_iff_integrable.2 (SignedMeasure.integrable_rnDeriv _ _)⟩
Theorem: linearIndependent_le_infinite_basis
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝⁴ : Ring R
inst✝³ : AddCommGroup M
inst✝² : Module R M
ι✝ : Type w
ι' : Type w'
inst✝¹ : StrongRankCondition R
ι : Type w
b : Basis ι R M
inst✝ : Infinite ι
κ : Type w
v : κ → M
i : LinearIndependent R v
⊢ #κ ≤ #ι
state_after: no goals
tactic: classical
  by_contra h
  rw [not_le, ← Cardinal.mk_finset_of_infinite ι] at h
  let Φ := fun k : κ => (b.repr (v k)).support
  obtain ⟨s, w : Infinite ↑(Φ ⁻¹' {s})⟩ := Cardinal.exists_infinite_fiber Φ h (by infer_instance)
  let v' := fun k : Φ ⁻¹' {s} => v k
  have i' : LinearIndependent R v' := i.comp _ Subtype.val_injective
  have w' : Finite (Φ ⁻¹' {s}) := by
    apply i'.finite_of_le_span_finite v' (s.image b)
    rintro m ⟨⟨p, ⟨rfl⟩⟩, rfl⟩
    simp only [SetLike.mem_coe, Subtype.coe_mk, Finset.coe_image]
    apply Basis.mem_span_repr_support
  exact w.false
Theorem: Polynomial.trailingDegree_ne_of_natTrailingDegree_ne
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
h : p.trailingDegree = ↑n
⊢ p.natTrailingDegree = n
state_after: no goals
tactic: rw [natTrailingDegree, h, ENat.toNat_coe]
Theorem: Ordinal.toPGame_lf_iff
File: Mathlib/SetTheory/Game/Ordinal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
⊢ a.toPGame ⧏ b.toPGame → a < b
state_after: a b : Ordinal.{u_1}
⊢ ¬a < b → ¬a.toPGame ⧏ b.toPGame
tactic: contrapose
state_before: a b : Ordinal.{u_1}
⊢ ¬a < b → ¬a.toPGame ⧏ b.toPGame
state_after: a b : Ordinal.{u_1}
⊢ b ≤ a → b.toPGame ≤ a.toPGame
tactic: rw [not_lt, not_lf]
state_before: a b : Ordinal.{u_1}
⊢ b ≤ a → b.toPGame ≤ a.toPGame
state_after: no goals
tactic: exact toPGame_le
Theorem: PartOrd.Iso.mk_hom
File: Mathlib/Order/Category/PartOrd.lean

Proof steps:
state_before: α β : PartOrd
e : ↑α ≃o ↑β
⊢ ↑e ≫ ↑e.symm = 𝟙 α
state_after: case w
α β : PartOrd
e : ↑α ≃o ↑β
x : (forget PartOrd).obj α
⊢ (↑e ≫ ↑e.symm) x = (𝟙 α) x
tactic: ext x
state_before: case w
α β : PartOrd
e : ↑α ≃o ↑β
x : (forget PartOrd).obj α
⊢ (↑e ≫ ↑e.symm) x = (𝟙 α) x
state_after: no goals
tactic: exact e.symm_apply_apply x
state_before: α β : PartOrd
e : ↑α ≃o ↑β
⊢ ↑e.symm ≫ ↑e = 𝟙 β
state_after: case w
α β : PartOrd
e : ↑α ≃o ↑β
x : (forget PartOrd).obj β
⊢ (↑e.symm ≫ ↑e) x = (𝟙 β) x
tactic: ext x
state_before: case w
α β : PartOrd
e : ↑α ≃o ↑β
x : (forget PartOrd).obj β
⊢ (↑e.symm ≫ ↑e) x = (𝟙 β) x
state_after: no goals
tactic: exact e.apply_symm_apply x
Theorem: SetTheory.PGame.Domineering.moveRight_card
File: Mathlib/SetTheory/Game/Domineering.lean

Proof steps:
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ Finset.card (moveRight b m) + 2 = Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ ((Finset.erase b m).erase (m.1 - 1, m.2)).card + 2 = Finset.card b
tactic: dsimp [moveRight]
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ ((Finset.erase b m).erase (m.1 - 1, m.2)).card + 2 = Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ (Finset.erase b m).card - 1 + 2 = Finset.card b
tactic: rw [Finset.card_erase_of_mem (fst_pred_mem_erase_of_mem_right h)]
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ (Finset.erase b m).card - 1 + 2 = Finset.card b
state_after: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ Finset.card b - 1 - 1 + 2 = Finset.card b
tactic: rw [Finset.card_erase_of_mem (Finset.mem_of_mem_inter_left h)]
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ Finset.card b - 1 - 1 + 2 = Finset.card b
state_after: no goals
tactic: exact tsub_add_cancel_of_le (card_of_mem_right h)
Theorem: EckmannHilton.mul_assoc
File: Mathlib/GroupTheory/EckmannHilton.lean

Proof steps:
state_before: X : Type u
m₁ m₂ : X → X → X
e₁ e₂ : X
h₁ : IsUnital m₁ e₁
h₂ : IsUnital m₂ e₂
distrib : ∀ (a b c d : X), m₁ (m₂ a b) (m₂ c d) = m₂ (m₁ a c) (m₁ b d)
a b c : X
⊢ m₂ (m₂ a b) c = m₂ a (m₂ b c)
state_after: no goals
tactic: simpa [mul h₁ h₂ distrib, h₂.left_id, h₂.right_id] using distrib a b e₂ c
Theorem: MeasureTheory.Measure.singularPart_eq_zero
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
⊢ μ.singularPart ν = 0 ↔ μ ≪ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ μ.singularPart ν = 0 ↔ μ ≪ ν
tactic: have h_dec := haveLebesgueDecomposition_add μ ν
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
⊢ μ.singularPart ν = 0 ↔ μ ≪ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ μ ≪ ν
tactic: refine ⟨fun h ↦ ?_, singularPart_eq_zero_of_ac⟩
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ μ ≪ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ μ ≪ ν
tactic: rw [h, zero_add] at h_dec
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ μ ≪ ν
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ ν.withDensity (μ.rnDeriv ν) ≪ ν
tactic: rw [h_dec]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
h_dec : μ = ν.withDensity (μ.rnDeriv ν)
h : μ.singularPart ν = 0
⊢ ν.withDensity (μ.rnDeriv ν) ≪ ν
state_after: no goals
tactic: exact withDensity_absolutelyContinuous ν _
Theorem: CategoryTheory.simplicialToCosimplicialAugmented_map_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom =
    ((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom).app x =
    (((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)).app x
tactic: ext x
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => (unop X).rightOp) Y✝).hom).app x =
    (((fun X => (unop X).rightOp) X✝).hom ≫ (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)).app x
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ f.unop.right.op ≫ ((unop Y✝).hom.app (op x)).op = ((unop X✝).hom.app (op x)).op ≫ (f.unop.left.app (op x)).op
tactic: dsimp
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ f.unop.right.op ≫ ((unop Y✝).hom.app (op x)).op = ((unop X✝).hom.app (op x)).op ≫ (f.unop.left.app (op x)).op
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((unop Y✝).hom.app (op x) ≫ f.unop.right).op = (f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)).op
tactic: simp_rw [← op_comp]
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ ((unop Y✝).hom.app (op x) ≫ f.unop.right).op = (f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)).op
state_after: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ (unop Y✝).hom.app (op x) ≫ f.unop.right = f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)
tactic: congr 1
state_before: case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ (unop Y✝).hom.app (op x) ≫ f.unop.right = f.unop.left.app (op x) ≫ (unop X✝).hom.app (op x)
state_after: no goals
tactic: exact (congr_app f.unop.w (op x)).symm
Theorem: ne_one_of_map
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F✝ : Type u_9
inst✝⁶ : One M
inst✝⁵ : One N
inst✝⁴ : FunLike F✝ M N
R : Type u_10
S : Type u_11
F : Type u_12
inst✝³ : One R
inst✝² : One S
inst✝¹ : FunLike F R S
inst✝ : OneHomClass F R S
f : F
x : R
hx : f x ≠ 1
⊢ f x ≠ f 1
state_after: no goals
tactic: rwa [(map_one f)]
Theorem: Quiver.Path.eq_of_length_zero
File: Mathlib/Combinatorics/Quiver/Path.lean

Proof steps:
state_before: V : Type u
inst✝ : Quiver V
a b c d : V
p : Path a b
hzero : p.length = 0
⊢ a = b
state_after: case nil
V : Type u
inst✝ : Quiver V
a c d : V
hzero : nil.length = 0
⊢ a = a

case cons
V : Type u
inst✝ : Quiver V
a b c d b✝ : V
a✝¹ : Path a b✝
a✝ : b✝ ⟶ b
hzero : (a✝¹.cons a✝).length = 0
⊢ a = b
tactic: cases p
Theorem: PolyEquivTensor.toFunLinear_mul_tmul_mul
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a₁ a₂ : A
p₁ p₂ : R[X]
⊢ (toFunLinear R A) ((a₁ * a₂) ⊗ₜ[R] (p₁ * p₂)) = (toFunLinear R A) (a₁ ⊗ₜ[R] p₁) * (toFunLinear R A) (a₂ ⊗ₜ[R] p₂)
state_after: no goals
tactic: classical
    simp only [toFunLinear_tmul_apply, toFunBilinear_apply_eq_sum]
    ext k
    simp_rw [coeff_sum, coeff_monomial, sum_def, Finset.sum_ite_eq', mem_support_iff, Ne]
    conv_rhs => rw [coeff_mul]
    simp_rw [finset_sum_coeff, coeff_monomial, Finset.sum_ite_eq', mem_support_iff, Ne, mul_ite,
      mul_zero, ite_mul, zero_mul]
    simp_rw [← ite_zero_mul (¬coeff p₁ _ = 0) (a₁ * (algebraMap R A) (coeff p₁ _))]
    simp_rw [← mul_ite_zero (¬coeff p₂ _ = 0) _ (_ * _)]
    simp_rw [toFunLinear_mul_tmul_mul_aux_1, toFunLinear_mul_tmul_mul_aux_2]
Theorem: AddMonoid.Coprod.comp_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : Monoid P
P' : Type u_4
inst✝ : Monoid P'
f : P →* P'
g₁ : M →* P
g₂ : N →* P
⊢ (f.comp (lift g₁ g₂)).comp inl = (lift (f.comp g₁) (f.comp g₂)).comp inl
state_after: no goals
tactic: rw [MonoidHom.comp_assoc, lift_comp_inl, lift_comp_inl]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : Monoid P
P' : Type u_4
inst✝ : Monoid P'
f : P →* P'
g₁ : M →* P
g₂ : N →* P
⊢ (f.comp (lift g₁ g₂)).comp inr = (lift (f.comp g₁) (f.comp g₂)).comp inr
state_after: no goals
tactic: rw [MonoidHom.comp_assoc, lift_comp_inr, lift_comp_inr]
Theorem: PiTensorProduct.ext
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ₁ φ₂ : (⨂[R] (i : ι), s i) →ₗ[R] E
H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)
⊢ φ₁ = φ₂
state_after: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ₁ φ₂ : (⨂[R] (i : ι), s i) →ₗ[R] E
H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)
⊢ ∀ (x : ⨂[R] (i : ι), s i), φ₁ x = φ₂ x
tactic: refine LinearMap.ext ?_
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ₁ φ₂ : (⨂[R] (i : ι), s i) →ₗ[R] E
H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)
⊢ ∀ (x : ⨂[R] (i : ι), s i), φ₁ x = φ₂ x
state_after: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ₁ φ₂ : (⨂[R] (i : ι), s i) →ₗ[R] E
H : φ₁.compMultilinearMap (tprod R) = φ₂.compMultilinearMap (tprod R)
z : ⨂[R] (i : ι), s i
⊢ ∀ (r : R) (f : (i : ι) → s i), φ₁ (tprodCoeff R r f) = φ₂ (tprodCoeff R r f)
tactic: refine fun z ↦
    PiTensorProduct.induction_on' z ?_ fun {x y} hx hy ↦ by rw [φ₁.map_add, φ₂.map_add, hx, hy]
Theorem: Nat.testBit_eq_inth
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n i : ℕ
⊢ n.testBit i = n.bits.getI i
state_after: case zero
n : ℕ
⊢ n.testBit 0 = n.bits.getI 0

case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ n.testBit (i + 1) = n.bits.getI (i + 1)
tactic: induction' i with i ih generalizing n
state_before: case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ n.testBit (i + 1) = n.bits.getI (i + 1)
state_after: case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ (bit n.bodd n.div2).testBit (i + 1) = n.bits.getI (i + 1)
tactic: conv_lhs => rw [← bit_decomp n]
state_before: case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ (bit n.bodd n.div2).testBit (i + 1) = n.bits.getI (i + 1)
state_after: case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ n.bits.tail.getI i = n.bits.getI (i + 1)
tactic: rw [testBit_bit_succ, ih n.div2, div2_bits_eq_tail]
state_before: case succ
i : ℕ
ih : ∀ (n : ℕ), n.testBit i = n.bits.getI i
n : ℕ
⊢ n.bits.tail.getI i = n.bits.getI (i + 1)
state_after: no goals
tactic: cases n.bits <;> simp
Theorem: CategoryTheory.Preadditive.IsIso.comp_left_eq_zero
File: Mathlib/CategoryTheory/Preadditive/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
P Q R : C
f f' : P ⟶ Q
g g' : Q ⟶ R
inst✝ : IsIso f
⊢ f ≫ g = 0 ↔ g = 0
state_after: no goals
tactic: rw [← IsIso.eq_inv_comp, Limits.comp_zero]
Theorem: CategoryTheory.Limits.Types.isConnected_iff_of_final
File: Mathlib/CategoryTheory/Limits/IsConnected.lean

Proof steps:
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
C : Type u
D : Type u₂
inst✝² : Category.{v, u} C
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.Final
⊢ IsConnected C ↔ IsConnected D
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
C : Type u
D : Type u₂
inst✝² : Category.{v, u} C
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.Final
⊢ Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{(max v u v₂ u₂) + 1}) ↔
    Nonempty (colimit (constPUnitFunctor D) ≅ PUnit.{(max v u v₂ u₂) + 1})
tactic: rw [isConnected_iff_colimit_constPUnitFunctor_iso_pUnit.{max v u v₂ u₂} C,
    isConnected_iff_colimit_constPUnitFunctor_iso_pUnit.{max v u v₂ u₂} D]
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
C : Type u
D : Type u₂
inst✝² : Category.{v, u} C
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.Final
⊢ Nonempty (colimit (constPUnitFunctor C) ≅ PUnit.{(max v u v₂ u₂) + 1}) ↔
    Nonempty (colimit (constPUnitFunctor D) ≅ PUnit.{(max v u v₂ u₂) + 1})
state_after: no goals
tactic: exact Equiv.nonempty_congr <| Iso.isoCongrLeft <|
    CategoryTheory.Functor.Final.colimitIso F <| constPUnitFunctor.{max u v u₂ v₂} D
Theorem: WithBot.coe_lt_coe
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LT α
⊢ ↑a < ↑b ↔ a < b
state_after: no goals
tactic: simp [LT.lt]
Theorem: Finset.Ici_add_Ici_subset
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : Preorder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LE.le
inst✝ : LocallyFiniteOrderTop α
a b : α
⊢ ↑(Ici a * Ici b) ⊆ ↑(Ici (a * b))
state_after: no goals
tactic: simpa using Set.Ici_mul_Ici_subset' _ _
Theorem: IsOpen.add_right
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
hs : IsOpen s
⊢ IsOpen (s * t)
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
hs : IsOpen s
⊢ IsOpen (⋃ a ∈ t, op a • s)
tactic: rw [← iUnion_op_smul_set]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul αᵐᵒᵖ α
s t : Set α
hs : IsOpen s
⊢ IsOpen (⋃ a ∈ t, op a • s)
state_after: no goals
tactic: exact isOpen_biUnion fun a _ => hs.smul _
Theorem: PartialHomeomorph.contDiffOn_univUnitBall_symm
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

Proof steps:
state_before: n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
⊢ ContDiffWithinAt ℝ n (↑univUnitBall.symm) (ball 0 1) y
state_after: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
⊢ ContDiffAt ℝ n (↑univUnitBall.symm) y
tactic: apply ContDiffAt.contDiffWithinAt
state_before: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
⊢ ContDiffAt ℝ n (↑univUnitBall.symm) y
state_after: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
⊢ ContDiffAt ℝ n (fun y => (√(1 - ‖y‖ ^ 2))⁻¹) y
tactic: suffices ContDiffAt ℝ n (fun y : E => (√(1 - ‖y‖ ^ 2 : ℝ))⁻¹) y from this.smul contDiffAt_id
state_before: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
⊢ ContDiffAt ℝ n (fun y => (√(1 - ‖y‖ ^ 2))⁻¹) y
state_after: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => (√(1 - ‖y‖ ^ 2))⁻¹) y
tactic: have h : (0 : ℝ) < (1 : ℝ) - ‖(y : E)‖ ^ 2 := by
    rwa [mem_ball_zero_iff, ← _root_.abs_one, ← abs_norm, ← sq_lt_sq, one_pow, ← sub_pos] at hy
state_before: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => (√(1 - ‖y‖ ^ 2))⁻¹) y
state_after: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => √(1 - ‖y‖ ^ 2)) y
tactic: refine ContDiffAt.inv ?_ (Real.sqrt_ne_zero'.mpr h)
state_before: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => √(1 - ‖y‖ ^ 2)) y
state_after: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => 1 - ‖y‖ ^ 2) y
tactic: refine (contDiffAt_sqrt h.ne').comp y ?_
state_before: case h
n : ℕ∞
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
y : E
hy : y ∈ ball 0 1
h : 0 < 1 - ‖y‖ ^ 2
⊢ ContDiffAt ℝ n (fun y => 1 - ‖y‖ ^ 2) y
state_after: no goals
tactic: exact contDiffAt_const.sub (contDiff_norm_sq ℝ).contDiffAt