1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.ZeroAtFilter.boundedAtFilter
File: Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean

tactic: rw [ZeroAtFilter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : l.ZeroAtFilter f
⊢ l.BoundedAtFilter f
state_after: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : f =o[l] fun _x => 1
⊢ l.BoundedAtFilter f

tactic: exact hf.isBigO
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NormedAddCommGroup β
l : Filter α
f : α → β
hf : f =o[l] fun _x => 1
⊢ l.BoundedAtFilter f
state_after: no goals
Theorem: Option.casesOn'_eq_elim
File: Mathlib/Data/Option/Basic.lean

tactic: cases a <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
b : β
f : α → β
a : Option α
⊢ a.casesOn' b f = a.elim b f
state_after: no goals
Theorem: Set.infinite_univ_iff
File: Mathlib/Data/Set/Finite.lean

tactic: rw [Set.Infinite, finite_univ_iff, not_finite_iff_infinite]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
⊢ univ.Infinite ↔ Infinite α
state_after: no goals
Theorem: Nat.image_cast_int_Ioo
File: Mathlib/Data/Nat/Cast/SetInterval.lean

tactic: simp [ordConnected_Ici]
state_before: a b : ℕ
⊢ (range ⇑castOrderEmbedding).OrdConnected
state_after: no goals
Theorem: Equiv.Perm.toList_formPerm_singleton
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
p : Perm α
x✝ x y : α
⊢ [x].formPerm.toList y = []
state_after: no goals
Theorem: Int.lt_or_le
File: Mathlib/Data/Int/Defs.lean

tactic: rw [← Int.not_lt]
state_before: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ b ≤ a
state_after: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ ¬a < b

tactic: exact em _
state_before: a✝¹ b✝¹ c✝ d m n a✝ b✝ c a b : ℤ
⊢ a < b ∨ ¬a < b
state_after: no goals
Theorem: Rat.normalize_num_den'
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: refine ⟨num.natAbs.gcd den, Nat.gcd_ne_zero_right nz, ?_⟩
state_before: num : Int
den : Nat
nz : den ≠ 0
⊢ ∃ d, d ≠ 0 ∧ num = (normalize num den nz).num * ↑d ∧ den = (normalize num den nz).den * d
state_after: num : Int
den : Nat
nz : den ≠ 0
⊢ num = (normalize num den nz).num * ↑(num.natAbs.gcd den) ∧ den = (normalize num den nz).den * num.natAbs.gcd den

tactic: simp [normalize_eq, Int.ediv_mul_cancel (Int.ofNat_dvd_left.2 <| Nat.gcd_dvd_left ..),
  Nat.div_mul_cancel (Nat.gcd_dvd_right ..)]
state_before: num : Int
den : Nat
nz : den ≠ 0
⊢ num = (normalize num den nz).num * ↑(num.natAbs.gcd den) ∧ den = (normalize num den nz).den * num.natAbs.gcd den
state_after: no goals
Theorem: AddCommGroup.modEq_comm
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, ← neg_eq_iff_eq_neg]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
⊢ (∃ b_1, b - a = (Equiv.symm (Equiv.neg ℤ)) b_1 • p) ↔ b ≡ a [PMOD p]
state_after: no goals
Theorem: Dilation.diam_image
File: Mathlib/Topology/MetricSpace/Dilation.lean

tactic: simp [Metric.diam, ediam_image, ENNReal.toReal_mul]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
F : Type u_4
G : Type u_5
inst✝³ : PseudoMetricSpace α
inst✝² : PseudoMetricSpace β
inst✝¹ : FunLike F α β
inst✝ : DilationClass F α β
f : F
s : Set α
⊢ Metric.diam (⇑f '' s) = ↑(ratio f) * Metric.diam s
state_after: no goals
Theorem: EisensteinSeries.norm_eq_max_natAbs
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: rw [← coe_nnnorm, ← NNReal.coe_natCast, NNReal.coe_inj, Nat.cast_max]
state_before: z : ℍ
x : Fin 2 → ℤ
⊢ ‖x‖ = ↑(max (x 0).natAbs (x 1).natAbs)
state_after: z : ℍ
x : Fin 2 → ℤ
⊢ ‖x‖₊ = max ↑(x 0).natAbs ↑(x 1).natAbs

tactic: refine eq_of_forall_ge_iff fun c ↦ ?_
state_before: z : ℍ
x : Fin 2 → ℤ
⊢ ‖x‖₊ = max ↑(x 0).natAbs ↑(x 1).natAbs
state_after: z : ℍ
x : Fin 2 → ℤ
c : NNReal
⊢ ‖x‖₊ ≤ c ↔ max ↑(x 0).natAbs ↑(x 1).natAbs ≤ c

tactic: simp only [pi_nnnorm_le_iff, Fin.forall_fin_two, max_le_iff, NNReal.natCast_natAbs]
state_before: z : ℍ
x : Fin 2 → ℤ
c : NNReal
⊢ ‖x‖₊ ≤ c ↔ max ↑(x 0).natAbs ↑(x 1).natAbs ≤ c
state_after: no goals
Theorem: DirectSum.sum_support_decompose
File: Mathlib/Algebra/DirectSum/Decomposition.lean

tactic: conv_rhs =>
  rw [← (decompose ℳ).symm_apply_apply r, ← sum_support_of (fun i ↦ ℳ i) (decompose ℳ r)]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)
r : M
⊢ ∑ i ∈ DFinsupp.support ((decompose ℳ) r), ↑(((decompose ℳ) r) i) = r
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)
r : M
⊢ ∑ i ∈ DFinsupp.support ((decompose ℳ) r), ↑(((decompose ℳ) r) i) =
    (decompose ℳ).symm (∑ i ∈ DFinsupp.support ((decompose ℳ) r), (of (fun i => ↥(ℳ i)) i) (((decompose ℳ) r) i))

tactic: rw [decompose_symm_sum]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)
r : M
⊢ ∑ i ∈ DFinsupp.support ((decompose ℳ) r), ↑(((decompose ℳ) r) i) =
    (decompose ℳ).symm (∑ i ∈ DFinsupp.support ((decompose ℳ) r), (of (fun i => ↥(ℳ i)) i) (((decompose ℳ) r) i))
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)
r : M
⊢ ∑ i ∈ DFinsupp.support ((decompose ℳ) r), ↑(((decompose ℳ) r) i) =
    ∑ i ∈ DFinsupp.support ((decompose ℳ) r), (decompose ℳ).symm ((of (fun i => ↥(ℳ i)) i) (((decompose ℳ) r) i))

tactic: simp_rw [decompose_symm_of]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
σ : Type u_4
inst✝⁵ : DecidableEq ι
inst✝⁴ : AddCommMonoid M
inst✝³ : SetLike σ M
inst✝² : AddSubmonoidClass σ M
ℳ : ι → σ
inst✝¹ : Decomposition ℳ
inst✝ : (i : ι) → (x : ↥(ℳ i)) → Decidable (x ≠ 0)
r : M
⊢ ∑ i ∈ DFinsupp.support ((decompose ℳ) r), ↑(((decompose ℳ) r) i) =
    ∑ i ∈ DFinsupp.support ((decompose ℳ) r), (decompose ℳ).symm ((of (fun i => ↥(ℳ i)) i) (((decompose ℳ) r) i))
state_after: no goals
Theorem: Cardinal.lift_iInf
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: unfold iInf
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (iInf f) = ⨅ i, lift.{u, v} (f i)
state_after: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (sInf (range f)) = sInf (range fun i => lift.{u, v} (f i))

tactic: convert lift_sInf (range f)
state_before: α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ lift.{u, v} (sInf (range f)) = sInf (range fun i => lift.{u, v} (f i))
state_after: case h.e'_3.h.e'_3
α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ (range fun i => lift.{u, v} (f i)) = lift.{u, v} '' range f

tactic: simp_rw [← comp_apply (f := lift), range_comp]
state_before: case h.e'_3.h.e'_3
α β : Type u
ι : Sort u_1
f : ι → Cardinal.{v}
⊢ (range fun i => lift.{u, v} (f i)) = lift.{u, v} '' range f
state_after: no goals
Theorem: Equiv.optionSubtype_symm_apply_symm_apply
File: Mathlib/Logic/Equiv/Option.lean

tactic: simp only [optionSubtype, coe_fn_symm_mk, Subtype.coe_mk,
           Subtype.coe_eta, dite_eq_ite, ite_eq_right_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : α ≃ { y // y ≠ x }
b : { y // y ≠ x }
⊢ (↑((optionSubtype x).symm e)).symm ↑b = some (e.symm b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : α ≃ { y // y ≠ x }
b : { y // y ≠ x }
⊢ ↑b = x → False

tactic: exact fun h => False.elim (b.property h)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
x : β
e : α ≃ { y // y ≠ x }
b : { y // y ≠ x }
⊢ ↑b = x → False
state_after: no goals
Theorem: SimpleGraph.Walk.toSubgraph_append
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*, sup_assoc]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w : V
p : G.Walk u v
q : G.Walk v w
⊢ (p.append q).toSubgraph = p.toSubgraph ⊔ q.toSubgraph
state_after: no goals
Theorem: Pi.uniformSpace_comap_restrict
File: Mathlib/Topology/UniformSpace/Pi.lean

tactic: simp (config := { unfoldPartialApp := true })
  [← iInf_subtype'', ← uniformSpace_comap_precomp' _ ((↑) : S → ι), Set.restrict]
state_before: ι : Type u_1
ι' : Type u_2
β : Type u_3
α : ι → Type u
U : (i : ι) → UniformSpace (α i)
inst✝ : UniformSpace β
S : Set ι
⊢ UniformSpace.comap S.restrict (uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (eval i) (U i)
state_after: no goals
Theorem: Multiset.prod_map_erase
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

tactic: rw [← m.coe_toList, coe_erase, map_coe, map_coe, prod_coe, prod_coe,
  List.prod_map_erase f (mem_toList.2 h)]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq ι
a : ι
h : a ∈ m
⊢ f a * (map f (m.erase a)).prod = (map f m).prod
state_after: no goals
Theorem: Asymptotics.isBigOWith_norm_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigOWith_def, norm_norm]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
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✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ IsBigOWith c l (fun x => ‖f' x‖) g ↔ IsBigOWith c l f' g
state_after: no goals
Theorem: Finset.filter_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨a, b⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a : α
b : β
p : α → Prop
q : β → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
⊢ filter (fun x => p x.1 ∧ q x.2) (s ×ˢ t) = filter p s ×ˢ filter q t
state_after: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a✝ : α
b✝ : β
p : α → Prop
q : β → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
b : β
⊢ (a, b) ∈ filter (fun x => p x.1 ∧ q x.2) (s ×ˢ t) ↔ (a, b) ∈ filter p s ×ˢ filter q t

tactic: simp [mem_filter, mem_product, decide_eq_true_eq, and_comm, and_left_comm, and_assoc]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type u_3
s s' : Finset α
t t' : Finset β
a✝ : α
b✝ : β
p : α → Prop
q : β → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
a : α
b : β
⊢ (a, b) ∈ filter (fun x => p x.1 ∧ q x.2) (s ×ˢ t) ↔ (a, b) ∈ filter p s ×ˢ filter q t
state_after: no goals
Theorem: GaussianInt.toComplex_div_re
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

tactic: rw [div_def, ← @Rat.round_cast ℝ _ _]
state_before: x y : ℤ[i]
⊢ (toComplex (x / y)).re = ↑(round (toComplex x / toComplex y).re)
state_after: x y : ℤ[i]
⊢ (toComplex { re := round ↑(↑(x * star y).re / ↑(norm y)), im := round (↑(x * star y).im / ↑(norm y)) }).re =
    ↑(round (toComplex x / toComplex y).re)

tactic: simp [-Rat.round_cast, mul_assoc, div_eq_mul_inv, mul_add, add_mul]
state_before: x y : ℤ[i]
⊢ (toComplex { re := round ↑(↑(x * star y).re / ↑(norm y)), im := round (↑(x * star y).im / ↑(norm y)) }).re =
    ↑(round (toComplex x / toComplex y).re)
state_after: no goals
Theorem: CategoryTheory.Localization.Construction.fac
File: Mathlib/CategoryTheory/Localization/Construction.lean

tactic: intro X Y f
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
⊢ ∀ (X Y : C) (f : X ⟶ Y), (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯

tactic: simp only [Functor.comp_map, eqToHom_refl, comp_id, id_comp]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (W.Q ⋙ lift G hG).map f = eqToHom ⋯ ≫ G.map f ≫ eqToHom ⋯
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (lift G hG).map (W.Q.map f) = G.map f

tactic: dsimp [MorphismProperty.Q, Quot.liftOn, Quotient.functor]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ (lift G hG).map (W.Q.map f) = G.map f
state_after: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ composePath (G.map f).toPath = G.map f

tactic: rw [composePath_toPath]
state_before: C : Type uC
inst✝¹ : Category.{uC', uC} C
W : MorphismProperty C
D : Type uD
inst✝ : Category.{uD', uD} D
G : C ⥤ D
hG : W.IsInvertedBy G
X Y : C
f : X ⟶ Y
⊢ composePath (G.map f).toPath = G.map f
state_after: no goals
Theorem: dvd_neg
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

tactic: simp only [Equiv.neg_symm, Equiv.neg_apply, mul_neg, neg_inj, Dvd.dvd]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Semigroup α
inst✝ : HasDistribNeg α
a b c : α
⊢ (∃ b_1, -b = a * (Equiv.symm (Equiv.neg α)) b_1) ↔ a ∣ b
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addX_of_Z_eq_zero_right
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [addX, hQz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQz : Q z = 0
⊢ W'.addX P Q = (-(Q x * P z)) ^ 2 * P x
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQz : Q z = 0
⊢ P x * Q x ^ 2 * P z ^ 2 - 2 * P y * Q y * P z * 0 + P x ^ 2 * Q x * 0 ^ 2 - W'.a₁ * P x * Q y * P z ^ 2 * 0 -
                  W'.a₁ * P y * Q x * P z * 0 ^ 2 +
                2 * W'.a₂ * P x * Q x * P z ^ 2 * 0 ^ 2 -
              W'.a₃ * Q y * P z ^ 4 * 0 -
            W'.a₃ * P y * P z * 0 ^ 4 +
          W'.a₄ * Q x * P z ^ 4 * 0 ^ 2 +
        W'.a₄ * P x * P z ^ 2 * 0 ^ 4 +
      2 * W'.a₆ * P z ^ 4 * 0 ^ 4 =
    (-(Q x * P z)) ^ 2 * P x

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQz : Q z = 0
⊢ P x * Q x ^ 2 * P z ^ 2 - 2 * P y * Q y * P z * 0 + P x ^ 2 * Q x * 0 ^ 2 - W'.a₁ * P x * Q y * P z ^ 2 * 0 -
                  W'.a₁ * P y * Q x * P z * 0 ^ 2 +
                2 * W'.a₂ * P x * Q x * P z ^ 2 * 0 ^ 2 -
              W'.a₃ * Q y * P z ^ 4 * 0 -
            W'.a₃ * P y * P z * 0 ^ 4 +
          W'.a₄ * Q x * P z ^ 4 * 0 ^ 2 +
        W'.a₄ * P x * P z ^ 2 * 0 ^ 4 +
      2 * W'.a₆ * P z ^ 4 * 0 ^ 4 =
    (-(Q x * P z)) ^ 2 * P x
state_after: no goals
Theorem: rank_le
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: rw [Module.rank_def]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
⊢ Module.rank R M ≤ ↑n
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
⊢ ⨆ ι, #↑↑ι ≤ ↑n

tactic: apply ciSup_le'
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
⊢ ⨆ ι, #↑↑ι ≤ ↑n
state_after: case h
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
⊢ ∀ (i : { s // LinearIndependent (ι := { x // x ∈ s }) R Subtype.val }), #↑↑i ≤ ↑n

tactic: rintro ⟨s, li⟩
state_before: case h
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
⊢ ∀ (i : { s // LinearIndependent (ι := { x // x ∈ s }) R Subtype.val }), #↑↑i ≤ ↑n
state_after: case h.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
s : Set M
li : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
⊢ #↑↑⟨s, li⟩ ≤ ↑n

tactic: exact linearIndependent_bounded_of_finset_linearIndependent_bounded H _ li
state_before: case h.mk
R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
n : ℕ
H : ∀ (s : Finset M), (LinearIndependent R fun i => ↑i) → s.card ≤ n
s : Set M
li : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
⊢ #↑↑⟨s, li⟩ ≤ ↑n
state_after: no goals
Theorem: fderivWithin_const_apply
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [DifferentiableAt.fderivWithin (differentiableAt_const _) hxs]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderivWithin 𝕜 (fun x => c) s x = 0
state_after: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 (fun x => c) x = 0

tactic: exact fderiv_const_apply _
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
c : F
hxs : UniqueDiffWithinAt 𝕜 s x
⊢ fderiv 𝕜 (fun x => c) x = 0
state_after: no goals
Theorem: Equiv.swap_eq_refl_iff
File: Mathlib/Logic/Equiv/Basic.lean

tactic: refine ⟨fun h => (Equiv.refl _).injective ?_, fun h => h ▸ swap_self _⟩
state_before: α : Sort u_1
inst✝ : DecidableEq α
x y : α
⊢ swap x y = Equiv.refl α ↔ x = y
state_after: α : Sort u_1
inst✝ : DecidableEq α
x y : α
h : swap x y = Equiv.refl α
⊢ (Equiv.refl α) x = (Equiv.refl α) y

tactic: rw [← h, swap_apply_left, h, refl_apply]
state_before: α : Sort u_1
inst✝ : DecidableEq α
x y : α
h : swap x y = Equiv.refl α
⊢ (Equiv.refl α) x = (Equiv.refl α) y
state_after: no goals
Theorem: FiniteDimensional.finrank_zero_of_subsingleton
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: rw [finrank, rank_subsingleton', _root_.map_zero]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
inst✝² : Nontrivial R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : Subsingleton M
⊢ finrank R M = 0
state_after: no goals
Theorem: isIntegralCurve_iff_isIntegralCurveAt
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

tactic: obtain ⟨s, hs, h⟩ := isIntegralCurveAt_iff.mp (h t)
state_before: E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
h : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))
state_after: case intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s✝ s' : Set ℝ
t₀ : ℝ
h✝ : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
s : Set ℝ
hs : s ∈ 𝓝 t
h : IsIntegralCurveOn γ v s
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))

tactic: exact h t (mem_of_mem_nhds hs)
state_before: case intro.intro
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
H : Type u_2
inst✝³ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝² : TopologicalSpace M
inst✝¹ : ChartedSpace H M
inst✝ : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s✝ s' : Set ℝ
t₀ : ℝ
h✝ : ∀ (t : ℝ), IsIntegralCurveAt γ v t
t : ℝ
s : Set ℝ
hs : s ∈ 𝓝 t
h : IsIntegralCurveOn γ v s
⊢ HasMFDerivAt 𝓘(ℝ, ℝ) I γ t (ContinuousLinearMap.smulRight 1 (v (γ t)))
state_after: no goals
Theorem: ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_three
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean

tactic: rw [← eq_one_iff' p (prime_ne_zero p q hpq), ← eq_neg_one_iff' q,
  quadratic_reciprocity_three_mod_four hp3 hq3, neg_inj]
state_before: p q : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : Fact (Nat.Prime q)
hp3 : p % 4 = 3
hq3 : q % 4 = 3
hpq : p ≠ q
⊢ IsSquare ↑q ↔ ¬IsSquare ↑p
state_after: no goals