1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Basis.toDual_apply_left
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← b.toDual_total_left, b.total_repr]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
m : M
i : ι
⊢ (b.toDual m) (b i) = (b.repr m) i
state_after: no goals
Theorem: two_nsmul_lie_lmul_lmul_add_add_eq_zero
File: Mathlib/Algebra/Jordan/Basic.lean

tactic: symm
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆) = 0
state_after: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)

tactic: calc
  0 = ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆ := by
    rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
  _ = _ := by rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)
state_after: no goals

tactic: rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆
state_after: no goals

tactic: rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocCommRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆ = 2 • (⁅L a, L (b * c)⁆ + ⁅L b, L (c * a)⁆ + ⁅L c, L (a * b)⁆)
state_after: no goals
Theorem: ContinuousMap.liftCover_coe
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: rw [liftCover, coe_mk, Set.liftCover_coe _]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f g : C(α, β)
ι : Type u_5
S : ι → Set α
φ : (i : ι) → C(↑(S i), β)
hφ : ∀ (i j : ι) (x : α) (hxi : x ∈ S i) (hxj : x ∈ S j), (φ i) ⟨x, hxi⟩ = (φ j) ⟨x, hxj⟩
hS : ∀ (x : α), ∃ i, S i ∈ 𝓝 x
i : ι
x : ↑(S i)
⊢ (liftCover S φ hφ hS) ↑x = (φ i) x
state_after: no goals
Theorem: Bornology.isVonNBounded_biUnion
File: Mathlib/Analysis/LocallyConvex/Bounded.lean

tactic: have _ := hI.to_subtype
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι✝ : Type u_6
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ι : Type u_7
I : Set ι
hI : I.Finite
s : ι → Set E
⊢ IsVonNBounded 𝕜 (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, IsVonNBounded 𝕜 (s i)
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι✝ : Type u_6
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ι : Type u_7
I : Set ι
hI : I.Finite
s : ι → Set E
x✝ : Finite ↑I
⊢ IsVonNBounded 𝕜 (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, IsVonNBounded 𝕜 (s i)

tactic: rw [biUnion_eq_iUnion, isVonNBounded_iUnion, Subtype.forall]
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
E' : Type u_4
F : Type u_5
ι✝ : Type u_6
inst✝³ : SeminormedRing 𝕜
inst✝² : SMul 𝕜 E
inst✝¹ : Zero E
inst✝ : TopologicalSpace E
ι : Type u_7
I : Set ι
hI : I.Finite
s : ι → Set E
x✝ : Finite ↑I
⊢ IsVonNBounded 𝕜 (⋃ i ∈ I, s i) ↔ ∀ i ∈ I, IsVonNBounded 𝕜 (s i)
state_after: no goals
Theorem: Finset.inf_sdiff_left
File: Mathlib/Data/Finset/Lattice.lean

tactic: induction hs using Finset.Nonempty.cons_induction with
| singleton => rw [sup_singleton, inf_singleton]
| cons _ _ _ _ ih => rw [sup_cons, inf_cons, ih, sdiff_sup]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
hs : s.Nonempty
f : ι → α
a : α
⊢ (s.inf fun b => a \ f b) = a \ s.sup f
state_after: no goals

tactic: rw [sup_singleton, inf_singleton]
state_before: case singleton
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
f : ι → α
a : α
a✝ : ι
⊢ ({a✝}.inf fun b => a \ f b) = a \ {a✝}.sup f
state_after: no goals

tactic: rw [sup_cons, inf_cons, ih, sdiff_sup]
state_before: case cons
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : BooleanAlgebra α
s : Finset ι
f : ι → α
a : α
a✝ : ι
s✝ : Finset ι
h✝ : a✝ ∉ s✝
hs✝ : s✝.Nonempty
ih : (s✝.inf fun b => a \ f b) = a \ s✝.sup f
⊢ ((cons a✝ s✝ h✝).inf fun b => a \ f b) = a \ (cons a✝ s✝ h✝).sup f
state_after: no goals
Theorem: Orthonormal.inner_right_finsupp
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: classical
simpa [Finsupp.total_apply, Finsupp.inner_sum, orthonormal_iff_ite.mp hv] using Eq.symm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
⊢ ⟪v i, (Finsupp.total ι E 𝕜 v) l⟫_𝕜 = l i
state_after: no goals

tactic: simpa [Finsupp.total_apply, Finsupp.inner_sum, orthonormal_iff_ite.mp hv] using Eq.symm
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι : Type u_4
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
⊢ ⟪v i, (Finsupp.total ι E 𝕜 v) l⟫_𝕜 = l i
state_after: no goals
Theorem: ArithmeticFunction.zeta_pmul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
⊢ (↑ζ).pmul f = f
state_after: case h
R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
x : ℕ
⊢ ((↑ζ).pmul f) x = f x

tactic: cases x <;> simp [Nat.succ_ne_zero]
state_before: case h
R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
x : ℕ
⊢ ((↑ζ).pmul f) x = f x
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.whiskerLeft_naturality_id
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality_id]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
⊢ f ◁ θ.naturality (𝟙 a) ≫ f ◁ θ.app a ◁ H.mapId a =
    f ◁ G.mapId a ▷ θ.app a ≫ f ◁ (λ_ (θ.app a)).hom ≫ f ◁ (ρ_ (θ.app a)).inv
state_after: no goals
Theorem: RatFunc.liftOn'_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: rw [RatFunc.liftOn', liftOn_div _ _ _ f0]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn' f H = f p q
state_after: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'

tactic: apply liftOn_condition_of_liftOn'_condition H
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
⊢ ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
state_after: no goals
Theorem: quadratic_eq_zero_iff_discrim_eq_sq
File: Mathlib/Algebra/QuadraticDiscriminant.lean

tactic: refine ⟨discrim_eq_sq_of_quadratic_eq_zero, fun h ↦ ?_⟩
state_before: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha : a ≠ 0
x : R
⊢ a * x * x + b * x + c = 0 ↔ discrim a b c = (2 * a * x + b) ^ 2
state_after: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha : a ≠ 0
x : R
h : discrim a b c = (2 * a * x + b) ^ 2
⊢ a * x * x + b * x + c = 0

tactic: rw [discrim] at h
state_before: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha : a ≠ 0
x : R
h : discrim a b c = (2 * a * x + b) ^ 2
⊢ a * x * x + b * x + c = 0
state_after: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
⊢ a * x * x + b * x + c = 0

tactic: have ha : 2 * 2 * a ≠ 0 := mul_ne_zero (mul_ne_zero (NeZero.ne _) (NeZero.ne _)) ha
state_before: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
⊢ a * x * x + b * x + c = 0
state_after: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha✝ : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
ha : 2 * 2 * a ≠ 0
⊢ a * x * x + b * x + c = 0

tactic: apply mul_left_cancel₀ ha
state_before: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha✝ : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
ha : 2 * 2 * a ≠ 0
⊢ a * x * x + b * x + c = 0
state_after: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha✝ : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
ha : 2 * 2 * a ≠ 0
⊢ 2 * 2 * a * (a * x * x + b * x + c) = 2 * 2 * a * 0

tactic: linear_combination -h
state_before: R : Type u_1
inst✝² : CommRing R
a b c : R
inst✝¹ : NeZero 2
inst✝ : NoZeroDivisors R
ha✝ : a ≠ 0
x : R
h : b ^ 2 - 4 * a * c = (2 * a * x + b) ^ 2
ha : 2 * 2 * a ≠ 0
⊢ 2 * 2 * a * (a * x * x + b * x + c) = 2 * 2 * a * 0
state_after: no goals
Theorem: AddMonoidAlgebra.of'_mem_span
File: Mathlib/RingTheory/FiniteType.lean

tactic: refine ⟨fun h => ?_, fun h => Submodule.subset_span <| Set.mem_image_of_mem (of R M) h⟩
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
⊢ of' R M m ∈ span R (of' R M '' S) ↔ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R (of' R M '' S)
⊢ m ∈ S

tactic: erw [of', ← Finsupp.supported_eq_span_single, Finsupp.mem_supported,
  Finsupp.support_single_ne_zero _ (one_ne_zero' R)] at h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R (of' R M '' S)
⊢ m ∈ S
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S

tactic: simpa using h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : ↑{m} ⊆ S
⊢ m ∈ S
state_after: no goals
Theorem: CategoryTheory.finallySmall_of_small_weakly_terminal_set
File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

tactic: refine Functor.final_of_exists_of_isFiltered_of_fullyFaithful _ (fun i => ?_)
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
⊢ (fullSubcategoryInclusion fun x => x ∈ s).Final
state_after: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i : J
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)

tactic: obtain ⟨j, hj₁, hj₂⟩ := hs i
state_before: J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i : J
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
state_after: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (i ⟶ j)
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)

tactic: exact ⟨⟨j, hj₁⟩, hj₂⟩
state_before: case intro.intro
J : Type u
inst✝² : Category.{v, u} J
inst✝¹ : IsFilteredOrEmpty J
s : Set J
inst✝ : Small.{v, u} ↑s
hs : ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)
i j : J
hj₁ : j ∈ s
hj₂ : Nonempty (i ⟶ j)
⊢ ∃ c, Nonempty (i ⟶ (fullSubcategoryInclusion fun x => x ∈ s).obj c)
state_after: no goals
Theorem: OrthonormalBasis.det_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: simpa using e.toBasis.det_adjustToOrientation x
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ (e.adjustToOrientation x).toBasis.det = e.toBasis.det ∨ (e.adjustToOrientation x).toBasis.det = -e.toBasis.det
state_after: no goals
Theorem: Affine.Simplex.sum_centroidWeightsWithCircumcenter
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

tactic: simp_rw [sum_pointsWithCircumcenter, centroidWeightsWithCircumcenter, add_zero, ←
  fs.sum_centroidWeights_eq_one_of_nonempty ℝ h, ← sum_indicator_subset _ fs.subset_univ]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
fs : Finset (Fin (n + 1))
h : fs.Nonempty
⊢ ∑ i : PointsWithCircumcenterIndex n, centroidWeightsWithCircumcenter fs i = 1
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
fs : Finset (Fin (n + 1))
h : fs.Nonempty
⊢ (∑ x : Fin (n + 1), if x ∈ fs then (↑fs.card)⁻¹ else 0) = ∑ i : Fin (n + 1), (↑fs).indicator (centroidWeights ℝ fs) i

tactic: rcongr
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
fs : Finset (Fin (n + 1))
h : fs.Nonempty
⊢ (∑ x : Fin (n + 1), if x ∈ fs then (↑fs.card)⁻¹ else 0) = ∑ i : Fin (n + 1), (↑fs).indicator (centroidWeights ℝ fs) i
state_after: no goals
Theorem: Real.sSup_le
File: Mathlib/Data/Real/Archimedean.lean

tactic: rcases S.eq_empty_or_nonempty with (rfl | hS₂)
state_before: S : Set ℝ
a : ℝ
hS : ∀ x ∈ S, x ≤ a
ha : 0 ≤ a
⊢ sSup S ≤ a
state_after: case inl
a : ℝ
ha : 0 ≤ a
hS : ∀ x ∈ ∅, x ≤ a
⊢ sSup ∅ ≤ a

case inr
S : Set ℝ
a : ℝ
hS : ∀ x ∈ S, x ≤ a
ha : 0 ≤ a
hS₂ : S.Nonempty
⊢ sSup S ≤ a

tactic: exacts [sSup_empty.trans_le ha, csSup_le hS₂ hS]
state_before: case inl
a : ℝ
ha : 0 ≤ a
hS : ∀ x ∈ ∅, x ≤ a
⊢ sSup ∅ ≤ a

case inr
S : Set ℝ
a : ℝ
hS : ∀ x ∈ S, x ≤ a
ha : 0 ≤ a
hS₂ : S.Nonempty
⊢ sSup S ≤ a
state_after: no goals
Theorem: CategoryTheory.composePath_comp
File: Mathlib/CategoryTheory/PathCategory.lean

tactic: induction' g with Y' Z' g e ih
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
g : Path Y Z
⊢ composePath (f.comp g) = composePath f ≫ composePath g
state_after: case nil
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
⊢ composePath (f.comp Path.nil) = composePath f ≫ composePath Path.nil

case cons
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
Y' Z' : C
g : Path Y Y'
e : Y' ⟶ Z'
ih : composePath (f.comp g) = composePath f ≫ composePath g
⊢ composePath (f.comp (g.cons e)) = composePath f ≫ composePath (g.cons e)

tactic: simp
state_before: case nil
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
⊢ composePath (f.comp Path.nil) = composePath f ≫ composePath Path.nil
state_after: no goals

tactic: simp [ih]
state_before: case cons
C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y Z : C
f : Path X Y
Y' Z' : C
g : Path Y Y'
e : Y' ⟶ Z'
ih : composePath (f.comp g) = composePath f ≫ composePath g
⊢ composePath (f.comp (g.cons e)) = composePath f ≫ composePath (g.cons e)
state_after: no goals
Theorem: StrictConvexOn.strictMonoOn_derivWithin
File: Mathlib/Analysis/Convex/Deriv.lean

tactic: intro x hx y hy hxy
state_before: S : Set ℝ
f : ℝ → ℝ
x y f' : ℝ
hfc : StrictConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
⊢ StrictMonoOn (derivWithin f S) S
state_after: S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : StrictConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x < y
⊢ derivWithin f S x < derivWithin f S y

tactic: exact (hfc.derivWithin_lt_slope hx hy hxy (hfd x hx)).trans
  (hfc.slope_lt_derivWithin hx hy hxy (hfd y hy))
state_before: S : Set ℝ
f : ℝ → ℝ
x✝ y✝ f' : ℝ
hfc : StrictConvexOn ℝ S f
hfd : DifferentiableOn ℝ f S
x : ℝ
hx : x ∈ S
y : ℝ
hy : y ∈ S
hxy : x < y
⊢ derivWithin f S x < derivWithin f S y
state_after: no goals
Theorem: Int.fract_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ fract a ∧ fract a < 1 ∧ ∃ z, a - fract a = ↑z

tactic: exact ⟨fract_nonneg _, fract_lt_one _, ⟨⌊a⌋, sub_sub_cancel _ _⟩⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = b
⊢ 0 ≤ fract a ∧ fract a < 1 ∧ ∃ z, a - fract a = ↑z
state_after: no goals

tactic: rintro ⟨h₀, h₁, z, hz⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ (0 ≤ b ∧ b < 1 ∧ ∃ z, a - b = ↑z) → fract a = b
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ fract a = b

tactic: rw [← self_sub_floor, eq_comm, eq_sub_iff_add_eq, add_comm, ← eq_sub_iff_add_eq, hz,
  Int.cast_inj, floor_eq_iff, ← hz]
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ fract a = b
state_after: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ a - b ≤ a ∧ a < a - b + 1

tactic: constructor <;> simpa [sub_eq_add_neg, add_assoc]
state_before: case intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
h₀ : 0 ≤ b
h₁ : b < 1
z : ℤ
hz : a - b = ↑z
⊢ a - b ≤ a ∧ a < a - b + 1
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.map_addZ
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp [addZ]
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ addZ (⇑f ∘ P) (⇑f ∘ Q) = f (addZ P Q)
state_after: no goals
Theorem: Complex.taylorSeries_eq_on_ball'
File: Mathlib/Analysis/Complex/TaylorSeries.lean

tactic: convert taylorSeries_eq_on_ball hf hz using 3 with n
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ → E
c : ℂ
r : ℝ
hf✝ : DifferentiableOn ℂ f✝ (Metric.ball c r)
z : ℂ
hz : z ∈ Metric.ball c r
f : ℂ → ℂ
hf : DifferentiableOn ℂ f (Metric.ball c r)
⊢ ∑' (n : ℕ), (↑n !)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = f z
state_after: case h.e'_2.h.e'_5.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ → E
c : ℂ
r : ℝ
hf✝ : DifferentiableOn ℂ f✝ (Metric.ball c r)
z : ℂ
hz : z ∈ Metric.ball c r
f : ℂ → ℂ
hf : DifferentiableOn ℂ f (Metric.ball c r)
n : ℕ
⊢ (↑n !)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = (↑n !)⁻¹ • (z - c) ^ n • iteratedDeriv n f c

tactic: rw [mul_right_comm, smul_eq_mul, smul_eq_mul, mul_assoc]
state_before: case h.e'_2.h.e'_5.h
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f✝ : ℂ → E
c : ℂ
r : ℝ
hf✝ : DifferentiableOn ℂ f✝ (Metric.ball c r)
z : ℂ
hz : z ∈ Metric.ball c r
f : ℂ → ℂ
hf : DifferentiableOn ℂ f (Metric.ball c r)
n : ℕ
⊢ (↑n !)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = (↑n !)⁻¹ • (z - c) ^ n • iteratedDeriv n f c
state_after: no goals
Theorem: TopologicalGroup.of_comm_of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa using tendsto_id
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Group G✝
inst✝³ : TopologicalGroup G✝
inst✝² : TopologicalSpace α
f : α → G✝
s : Set α
x : α
G : Type u
inst✝¹ : CommGroup G
inst✝ : TopologicalSpace G
hmul : Tendsto (uncurry fun x x_1 => x * x_1) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
hinv : Tendsto (fun x => x⁻¹) (𝓝 1) (𝓝 1)
hleft : ∀ (x₀ : G), 𝓝 x₀ = map (fun x => x₀ * x) (𝓝 1)
⊢ ∀ (x₀ : G), Tendsto (fun x => x₀ * x * x₀⁻¹) (𝓝 1) (𝓝 1)
state_after: no goals
Theorem: PMF.binomial_apply_zero
File: Mathlib/Probability/ProbabilityMassFunction/Binomial.lean

tactic: simp [binomial_apply]
state_before: p : ℝ≥0∞
h : p ≤ 1
n : ℕ
⊢ (binomial p h n) 0 = (1 - p) ^ n
state_after: no goals
Theorem: sq_ne_two_fin_zmod_four
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: change Fin 4 at z
state_before: z : ZMod 4
⊢ z * z ≠ 2
state_after: z : Fin 4
⊢ z * z ≠ 2

tactic: fin_cases z <;> decide
state_before: z : Fin 4
⊢ z * z ≠ 2
state_after: no goals
Theorem: Option.orElse_eq_none
File: Mathlib/Data/Option/Basic.lean

tactic: cases o
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o o' : Option α
⊢ (HOrElse.hOrElse o fun x => o') = none ↔ o = none ∧ o' = none
state_after: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
⊢ (HOrElse.hOrElse none fun x => o') = none ↔ none = none ∧ o' = none

case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = none ↔ some val✝ = none ∧ o' = none

tactic: simp only [true_and, none_orElse, eq_self_iff_true]
state_before: case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
⊢ (HOrElse.hOrElse none fun x => o') = none ↔ none = none ∧ o' = none
state_after: no goals

tactic: simp only [some_orElse, false_and]
state_before: case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
o' : Option α
val✝ : α
⊢ (HOrElse.hOrElse (some val✝) fun x => o') = none ↔ some val✝ = none ∧ o' = none
state_after: no goals
Theorem: List.norm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
⊢ ‖[].prod‖ ≤ (map norm []).prod
state_after: no goals