ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.sigmaCurry_smul
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝² : Monoid γ
inst✝¹ : (i : ι) → (j : α i) → AddMonoid (δ i j)
inst✝ : (i : ι) → (j : α i) → DistribMulAction γ (δ i j)
r : γ
f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
⊢ (r • f).sigmaCurry = r • f.sigmaCurry
state_after: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝² : Monoid γ
inst✝¹ : (i : ι) → (j : α i) → AddMonoid (δ i j)
inst✝ : (i : ι) → (j : α i) → DistribMulAction γ (δ i j)
r : γ
f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((r • f).sigmaCurry i) j = ((r • f.sigmaCurry) i) j
tactic: ext (i j)
state_before: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
κ : Type u_1
α : ι → Type u_2
δ : (i : ι) → α i → Type v
inst✝² : Monoid γ
inst✝¹ : (i : ι) → (j : α i) → AddMonoid (δ i j)
inst✝ : (i : ι) → (j : α i) → DistribMulAction γ (δ i j)
r : γ
f : Π₀ (i : (x : ι) × α x), δ i.fst i.snd
i : ι
j : α i
⊢ ((r • f).sigmaCurry i) j = ((r • f.sigmaCurry) i) j
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Presieve.isSheafFor_iff_preservesProduct
File: Mathlib/CategoryTheory/Sites/Preserves.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
⊢ IsSheafFor F (ofArrows X c.inj) ↔ Nonempty (PreservesLimit (Discrete.functor fun x => op (X x)) F)
state_after: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
hF' : Nonempty (PreservesLimit (Discrete.functor fun x => op (X x)) F)
⊢ IsSheafFor F (ofArrows X c.inj)
tactic: refine ⟨fun hF' ↦ ⟨preservesProductOfIsSheafFor _ hF hI c hc hd hF'⟩, fun hF' ↦ ?_⟩
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
hF' : Nonempty (PreservesLimit (Discrete.functor fun x => op (X x)) F)
⊢ IsSheafFor F (ofArrows X c.inj)
state_after: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
hF' : Nonempty (PreservesLimit (Discrete.functor fun x => op (X x)) F)
x✝ : PreservesLimit (Discrete.functor fun x => op (X x)) F := hF'.some
⊢ IsSheafFor F (ofArrows X c.inj)
tactic: let _ := hF'.some
state_before: C : Type u
inst✝³ : Category.{v, u} C
I : C
F : Cᵒᵖ ⥤ Type w
hF : IsSheafFor F (ofArrows Empty.elim fun a => instIsEmptyEmpty.elim a)
hI : IsInitial I
α : Type
X : α → C
c : Cofan X
hc : IsColimit c
inst✝² : (ofArrows X c.inj).hasPullbacks
inst✝¹ : HasInitial C
inst✝ : ∀ (i : α), Mono (c.inj i)
hd : Pairwise fun i j => IsPullback (initial.to (X i)) (initial.to (X j)) (c.inj i) (c.inj j)
hF' : Nonempty (PreservesLimit (Discrete.functor fun x => op (X x)) F)
x✝ : PreservesLimit (Discrete.functor fun x => op (X x)) F := hF'.some
⊢ IsSheafFor F (ofArrows X c.inj)
state_after: no goals
tactic: exact isSheafFor_of_preservesProduct F c hc
Theorem: Orientation.oangle_add_left_eq_arctan_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ o.oangle (x + y) y = ↑(Real.arctan (‖x‖ / ‖y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (x + y) = ↑(Real.arctan (‖x‖ / ‖y‖))
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (x + y) = ↑(Real.arctan (‖x‖ / ‖y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (y + x) = ↑(Real.arctan (‖x‖ / ‖y‖))
tactic: rw [add_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (y + x) = ↑(Real.arctan (‖x‖ / ‖y‖))
state_after: no goals
tactic: exact (-o).oangle_add_right_eq_arctan_of_oangle_eq_pi_div_two h
Theorem: Num.cmp_eq
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
m n : Num
⊢ m.cmp n = Ordering.eq ↔ m = n
state_after: α : Type u_1
m n : Num
this : Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ m.cmp n = Ordering.eq ↔ m = n
tactic: have := cmp_to_nat m n
state_before: α : Type u_1
m n : Num
this : Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ m.cmp n = Ordering.eq ↔ m = n
state_after: α : Type u_1
m n : Num
⊢ Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m) → (m.cmp n = Ordering.eq ↔ m = n)
tactic: revert this
state_before: α : Type u_1
m n : Num
⊢ Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m) → (m.cmp n = Ordering.eq ↔ m = n)
state_after: no goals
tactic: cases cmp m n <;> intro this <;> simp at this ⊢ <;> try { exact this } <;>
    simp [show m ≠ n from fun e => by rw [e] at this; exact lt_irrefl _ this]
Theorem: Fin.lt_castPred_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
j : Fin n
i : Fin (n + 1)
hi : i ≠ last n
⊢ j < i.castPred hi ↔ j.castSucc < i
state_after: no goals
tactic: rw [← castSucc_lt_castSucc_iff, castSucc_castPred]
Theorem: List.dedup_eq_cons
File: Mathlib/Data/List/Dedup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
a : α
l' : List α
⊢ l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l'
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
a : α
l' : List α
h : l.dedup = a :: l'
⊢ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l'

case refine_2
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
a : α
l' : List α
h : a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l'
⊢ l.dedup = a :: l'
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: CategoryTheory.MonoidalCategory.whiskerLeft_whiskerLeft_associator_inv
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Z₁ Z₂ : C
f : Z₁ ⟶ Z₂
⊢ X ◁ Y ◁ f ≫ (α_ X Y Z₂).inv = (α_ X Y Z₁).inv ≫ (X ⊗ Y) ◁ f
state_after: no goals
tactic: simp
Theorem: ProjectiveSpectrum.basicOpen_pow
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
n : ℕ
hn : 0 < n
⊢ ↑(basicOpen 𝒜 (f ^ n)) = ↑(basicOpen 𝒜 f)
state_after: no goals
tactic: simpa using zeroLocus_singleton_pow 𝒜 f n hn
Theorem: CategoryTheory.Limits.Cones.whiskeringEquivalence_inverse
File: Mathlib/CategoryTheory/Limits/Cones.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cone (e.functor ⋙ F)
⊢ ∀ (j : K),
    (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).π.app j =
      (Iso.refl (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).pt).hom ≫
        ((𝟭 (Cone (e.functor ⋙ F))).obj s).π.app j
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cone (e.functor ⋙ F)
k : K
⊢ (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).π.app k =
    (Iso.refl (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).pt).hom ≫
      ((𝟭 (Cone (e.functor ⋙ F))).obj s).π.app k
tactic: intro k
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
e : K ≌ J
s : Cone (e.functor ⋙ F)
k : K
⊢ (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).π.app k =
    (Iso.refl (((whiskering e.inverse ⋙ postcompose (e.invFunIdAssoc F).hom) ⋙ whiskering e.functor).obj s).pt).hom ≫
      ((𝟭 (Cone (e.functor ⋙ F))).obj s).π.app k
state_after: no goals
tactic: simpa [e.counit_app_functor] using s.w (e.unitInv.app k)
Theorem: integrable_inv_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

Proof steps:
state_before: ⊢ Integrable (fun x => (1 + x ^ 2)⁻¹) volume
state_after: ⊢ Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-2 / 2)) volume
tactic: suffices Integrable fun (x : ℝ) ↦ (1 + ‖x‖ ^ 2) ^ ((-2 : ℝ) / 2) by simpa [rpow_neg_one]
state_before: ⊢ Integrable (fun x => (1 + ‖x‖ ^ 2) ^ (-2 / 2)) volume
state_after: no goals
tactic: exact integrable_rpow_neg_one_add_norm_sq (by simp)
Theorem: Matroid.Indep.exists_bijOn_of_map
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
I : Set β
hf : InjOn f M.E
hI : (M.map f hf).Indep I
⊢ ∃ I₀, M.Indep I₀ ∧ BijOn f I₀ I
state_after: case intro.intro
α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
I₀ : Set α
hI₀ : M.Indep I₀
⊢ ∃ I₀_1, M.Indep I₀_1 ∧ BijOn f I₀_1 (f '' I₀)
tactic: obtain ⟨I₀, hI₀, rfl⟩ := hI
state_before: case intro.intro
α : Type u_1
β : Type u_2
f : α → β
E I s : Set α
M : Matroid α
N : Matroid β
hf : InjOn f M.E
I₀ : Set α
hI₀ : M.Indep I₀
⊢ ∃ I₀_1, M.Indep I₀_1 ∧ BijOn f I₀_1 (f '' I₀)
state_after: no goals
tactic: exact ⟨I₀, hI₀, (hf.mono hI₀.subset_ground).bijOn_image⟩
Theorem: IsExtrFilter.hasLineDerivAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
f : E → ℝ
s : Set E
a b : E
f' : ℝ
l : Filter E
h : IsExtrFilter f l a
hd : HasLineDerivAt ℝ f f' a b
h' : Tendsto (fun t => a + t • b) (𝓝 0) l
⊢ IsExtrFilter f l (a + 0 • b)
state_after: no goals
tactic: simpa using h
Theorem: Finset.surj_on_of_inj_on_of_card_le
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t✝ u : Finset α
f✝ : α → β
n : ℕ
t : Finset β
f : (a : α) → a ∈ s → β
hf : ∀ (a : α) (ha : a ∈ s), f a ha ∈ t
hinj : ∀ (a₁ a₂ : α) (ha₁ : a₁ ∈ s) (ha₂ : a₂ ∈ s), f a₁ ha₁ = f a₂ ha₂ → a₁ = a₂
hst : t.card ≤ s.card
⊢ ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), b = f a ha
state_after: no goals
tactic: classical
  have h : (s.attach.image fun a : { a // a ∈ s } => f a a.prop).card = s.card := by
    rw [← @card_attach _ s, card_image_of_injective]
    intro ⟨_, _⟩ ⟨_, _⟩ h
    exact Subtype.eq <| hinj _ _ _ _ h
  obtain rfl : image (fun a : { a // a ∈ s } => f a a.prop) s.attach = t :=
    eq_of_subset_of_card_le (image_subset_iff.2 $ by simpa) (by simp [hst, h])
  simp only [mem_image, mem_attach, true_and, Subtype.exists, forall_exists_index]
  exact fun b a ha hb ↦ ⟨a, ha, hb.symm⟩
Theorem: StrictConcaveOn.slope_lt_of_hasDerivWithinAt
File: Mathlib/Analysis/Convex/Deriv.lean

Proof steps:
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConcaveOn ℝ S f
hx : x ∈ S
hy : y ∈ S
hxy : x < y
hfd : HasDerivWithinAt f f' S x
⊢ slope f x y < f'
state_after: no goals
tactic: simpa only [Pi.neg_def, slope_neg, neg_neg] using
    neg_lt_neg (hfc.neg.lt_slope_of_hasDerivWithinAt hx hy hxy hfd.neg)
Theorem: Set.toFinset_insert
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : DecidableEq α
a : α
s : Set α
inst✝¹ : Fintype ↑(insert a s)
inst✝ : Fintype ↑s
⊢ (insert a s).toFinset = insert a s.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : DecidableEq α
a : α
s : Set α
inst✝¹ : Fintype ↑(insert a s)
inst✝ : Fintype ↑s
a✝ : α
⊢ a✝ ∈ (insert a s).toFinset ↔ a✝ ∈ insert a s.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : DecidableEq α
a : α
s : Set α
inst✝¹ : Fintype ↑(insert a s)
inst✝ : Fintype ↑s
a✝ : α
⊢ a✝ ∈ (insert a s).toFinset ↔ a✝ ∈ insert a s.toFinset
state_after: no goals
tactic: simp
Theorem: CochainComplex.HomComplex.Cocycle.rightShift_coe
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ : Cocycle K L n
a n' : ℤ
hn' : n' + a = n
⊢ δ n' (n' + 1) ((↑γ).rightShift a n' hn') = 0
state_after: no goals
tactic: simp only [Cochain.δ_rightShift _ a n' (n' + 1) hn' (n + 1) (by omega),
      δ_eq_zero, Cochain.rightShift_zero, smul_zero]
Theorem: HasStrictDerivAt.mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
⊢ HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
state_after: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
this : HasStrictDerivAt (fun y => c y * d y) ((c x • smulRight 1 d' + (smulRight 1 c').smulRight (d x)) 1) x
⊢ HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
tactic: have := (HasStrictFDerivAt.mul' hc hd).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
this : HasStrictDerivAt (fun y => c y * d y) ((c x • smulRight 1 d' + (smulRight 1 c').smulRight (d x)) 1) x
⊢ HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
state_after: no goals
tactic: rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
    ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
    ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
    add_comm] at this
Theorem: Equiv.swap_comp_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : DecidableEq α
a b x : α
π : Perm α
⊢ (Equiv.trans π (swap a b)) x = if π x = a then b else if π x = b then a else π x
state_after: case mk
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
toFun✝ invFun✝ : α → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ ({ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (swap a b)) x =
    if { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = a then b
    else
      if { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = b then a
      else { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x
tactic: cases π
state_before: case mk
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
toFun✝ invFun✝ : α → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ ({ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (swap a b)) x =
    if { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = a then b
    else
      if { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = b then a
      else { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x
state_after: no goals
tactic: rfl
Theorem: Matroid.basis_ground_iff
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Basis B M.E ↔ M.Base B
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Indep B →
    ((B ⊆ M.E ∧ ∀ (J : Set α), M.Indep J → B ⊆ J → J ⊆ M.E → B = J) ∧ M.E ⊆ M.E ↔
      ∀ (I : Set α), M.Indep I → B ⊆ I → B = I)
tactic: rw [base_iff_maximal_indep, basis_iff', and_assoc, and_congr_right]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Indep B →
    ((B ⊆ M.E ∧ ∀ (J : Set α), M.Indep J → B ⊆ J → J ⊆ M.E → B = J) ∧ M.E ⊆ M.E ↔
      ∀ (I : Set α), M.Indep I → B ⊆ I → B = I)
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Indep B →
    ((B ⊆ M.E ∧ ∀ (J : Set α), M.Indep J → B ⊆ J → J ⊆ M.E → B = J) ↔ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I)
tactic: rw [and_iff_left (rfl.subset : M.E ⊆ M.E)]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
⊢ M.Indep B →
    ((B ⊆ M.E ∧ ∀ (J : Set α), M.Indep J → B ⊆ J → J ⊆ M.E → B = J) ↔ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I)
state_after: no goals
tactic: exact fun h ↦ ⟨fun h' I hI hBI ↦ h'.2 _ hI hBI hI.subset_ground,
    fun h' ↦ ⟨h.subset_ground,fun J hJ hBJ _ ↦ h' J hJ hBJ⟩⟩
Theorem: Nat.preimage_Ioo
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
ha : 0 ≤ a
⊢ Nat.cast ⁻¹' Ioo a b = Ioo ⌊a⌋₊ ⌈b⌉₊
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ioo a b ↔ x✝ ∈ Ioo ⌊a⌋₊ ⌈b⌉₊
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
ha : 0 ≤ a
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ioo a b ↔ x✝ ∈ Ioo ⌊a⌋₊ ⌈b⌉₊
state_after: no goals
tactic: simp [floor_lt, lt_ceil, ha]
Theorem: Nat.pair_lt_max_add_one_sq
File: Mathlib/Data/Nat/Pairing.lean

Proof steps:
state_before: m n : ℕ
⊢ pair m n < (max m n + 1) ^ 2
state_after: m n : ℕ
⊢ (if m < n then n * n + m else m * m + (m + n)) < max m n * max m n + (max m n + (max m n + 1))
tactic: simp only [pair, Nat.pow_two, Nat.mul_add, Nat.add_mul, Nat.mul_one, Nat.one_mul, Nat.add_assoc]
state_before: m n : ℕ
⊢ (if m < n then n * n + m else m * m + (m + n)) < max m n * max m n + (max m n + (max m n + 1))
state_after: no goals
tactic: split_ifs <;> simp [Nat.max_eq_left, Nat.max_eq_right, Nat.le_of_lt,  not_lt.1, *] <;> omega
Theorem: AddCon.sup_def
File: Mathlib/GroupTheory/Congruence/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ c ⊔ d = conGen (⇑c ⊔ ⇑d)
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ (conGen fun x y => c x y ∨ d x y) = conGen (⇑c ⊔ ⇑d)
tactic: rw [sup_eq_conGen]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ (conGen fun x y => c x y ∨ d x y) = conGen (⇑c ⊔ ⇑d)
state_after: no goals
tactic: rfl