1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousLinearMap.norm_precompL_le
File: Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean

tactic: rw [precompL, opNorm_flip, ← opNorm_flip L]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁹ : SeminormedAddCommGroup E
inst✝¹⁸ : SeminormedAddCommGroup Eₗ
inst✝¹⁷ : SeminormedAddCommGroup F
inst✝¹⁶ : SeminormedAddCommGroup Fₗ
inst✝¹⁵ : SeminormedAddCommGroup G
inst✝¹⁴ : SeminormedAddCommGroup Gₗ
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : NontriviallyNormedField 𝕜₃
inst✝¹⁰ : NormedSpace 𝕜 E
inst✝⁹ : NormedSpace 𝕜 Eₗ
inst✝⁸ : NormedSpace 𝕜₂ F
inst✝⁷ : NormedSpace 𝕜 Fₗ
inst✝⁶ : NormedSpace 𝕜₃ G
inst✝⁵ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : FunLike 𝓕 E F
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ ‖precompL Eₗ L‖ ≤ ‖L‖
state_after: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁹ : SeminormedAddCommGroup E
inst✝¹⁸ : SeminormedAddCommGroup Eₗ
inst✝¹⁷ : SeminormedAddCommGroup F
inst✝¹⁶ : SeminormedAddCommGroup Fₗ
inst✝¹⁵ : SeminormedAddCommGroup G
inst✝¹⁴ : SeminormedAddCommGroup Gₗ
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : NontriviallyNormedField 𝕜₃
inst✝¹⁰ : NormedSpace 𝕜 E
inst✝⁹ : NormedSpace 𝕜 Eₗ
inst✝⁸ : NormedSpace 𝕜₂ F
inst✝⁷ : NormedSpace 𝕜 Fₗ
inst✝⁶ : NormedSpace 𝕜₃ G
inst✝⁵ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : FunLike 𝓕 E F
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ ‖precompR Eₗ L.flip‖ ≤ ‖L.flip‖

tactic: exact norm_precompR_le _ L.flip
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹⁹ : SeminormedAddCommGroup E
inst✝¹⁸ : SeminormedAddCommGroup Eₗ
inst✝¹⁷ : SeminormedAddCommGroup F
inst✝¹⁶ : SeminormedAddCommGroup Fₗ
inst✝¹⁵ : SeminormedAddCommGroup G
inst✝¹⁴ : SeminormedAddCommGroup Gₗ
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : NontriviallyNormedField 𝕜₂
inst✝¹¹ : NontriviallyNormedField 𝕜₃
inst✝¹⁰ : NormedSpace 𝕜 E
inst✝⁹ : NormedSpace 𝕜 Eₗ
inst✝⁸ : NormedSpace 𝕜₂ F
inst✝⁷ : NormedSpace 𝕜 Fₗ
inst✝⁶ : NormedSpace 𝕜₃ G
inst✝⁵ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝⁴ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝³ : FunLike 𝓕 E F
inst✝² : RingHomIsometric σ₂₃
inst✝¹ : RingHomIsometric σ₁₃
inst✝ : RingHomIsometric σ₁₂
L : E →L[𝕜] Fₗ →L[𝕜] Gₗ
⊢ ‖precompR Eₗ L.flip‖ ≤ ‖L.flip‖
state_after: no goals
Theorem: Basis.det_map
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: rw [Basis.det_apply, Basis.toMatrix_map, Basis.det_apply]
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type u_3
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_4
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e : Basis ι R M
A : Type u_5
inst✝¹ : CommRing A
inst✝ : Module A M
b : Basis ι R M
f : M ≃ₗ[R] M'
v : ι → M'
⊢ (b.map f).det v = b.det (⇑f.symm ∘ v)
state_after: no goals
Theorem: Polynomial.C_mul_X_eq_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rw [← C_mul_X_pow_eq_monomial, pow_one]
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ C a * X = (monomial 1) a
state_after: no goals
Theorem: gcd_eq_right_iff
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: simpa only [gcd_comm a b] using gcd_eq_left_iff b a h
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b : α
h : normalize b = b
⊢ gcd a b = b ↔ b ∣ a
state_after: no goals
Theorem: SemidirectProduct.inl_aut_inv
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: rw [← MonoidHom.map_inv, inl_aut, inv_inv]
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
g : G
n : N
⊢ inl ((φ g)⁻¹ n) = inr g⁻¹ * inl n * inr g
state_after: no goals
Theorem: Nat.add_succ_lt_add
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.add_assoc]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hab : a < b
hcd : c < d
⊢ a + c + 1 < b + d
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
hab : a < b
hcd : c < d
⊢ a + (c + 1) < b + d

tactic: exact Nat.add_lt_add_of_lt_of_le hab (Nat.succ_le_iff.2 hcd)
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hab : a < b
hcd : c < d
⊢ a + (c + 1) < b + d
state_after: no goals
Theorem: Valuation.map_one_add_of_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [← v.map_one] at h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < 1
⊢ v (1 + x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < v 1
⊢ v (1 + x) = 1

tactic: simpa only [v.map_one] using v.map_add_eq_of_lt_left h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < v 1
⊢ v (1 + x) = 1
state_after: no goals
Theorem: Mathlib.Tactic.Ring.add_pf_add_lt
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [*, add_assoc]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₂ b c a₁ : R
x✝ : a₂ + b = c
⊢ a₁ + a₂ + b = a₁ + c
state_after: no goals
Theorem: Fin.snocCases_snoc
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [snocCases, cast_eq_iff_heq, Fin.init_snoc, Fin.snoc_last]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
P : ((i : Fin (n + 1)) → α i) → Sort u_1
h : (x : (i : Fin n) → α i.castSucc) → (x₀ : α (last n)) → P (snoc x x₀)
x : (i : Fin n) → init α i
x₀ : α (last n)
⊢ snocCases h (snoc x x₀) = h x x₀
state_after: no goals
Theorem: MvPolynomial.rename_prod_mk_eval₂
File: Mathlib/Algebra/MvPolynomial/Rename.lean

tactic: intros
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
j : τ
g : σ → MvPolynomial σ R
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (rename (Prod.mk j)) (eval₂ C g p) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) p →
      (rename (Prod.mk j)) (eval₂ C g (p * X n)) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) (p * X n)
state_after: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
j : τ
g : σ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : (rename (Prod.mk j)) (eval₂ C g p✝) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) p✝
⊢ (rename (Prod.mk j)) (eval₂ C g (p✝ * X n✝)) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) (p✝ * X n✝)

tactic: simp [*]
state_before: case h_X
σ : Type u_1
τ : Type u_2
α : Type u_3
R : Type u_4
S : Type u_5
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
f : R →+* S
k : σ → τ
g✝ : τ → S
p : MvPolynomial σ R
j : τ
g : σ → MvPolynomial σ R
p✝ : MvPolynomial σ R
n✝ : σ
a✝ : (rename (Prod.mk j)) (eval₂ C g p✝) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) p✝
⊢ (rename (Prod.mk j)) (eval₂ C g (p✝ * X n✝)) = eval₂ C (fun x => (rename (Prod.mk j)) (g x)) (p✝ * X n✝)
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RespectsIso.diagonal
File: Mathlib/CategoryTheory/MorphismProperty/Limits.lean

tactic: constructor
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
⊢ P.diagonal.RespectsIso
state_after: case left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
⊢ ∀ {X Y Z : C} (e : X ≅ Y) (f : Y ⟶ Z), P.diagonal f → P.diagonal (e.hom ≫ f)

case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y), P.diagonal f → P.diagonal (f ≫ e.hom)

tactic: introv H
state_before: case left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
⊢ ∀ {X Y Z : C} (e : X ≅ Y) (f : Y ⟶ Z), P.diagonal f → P.diagonal (e.hom ≫ f)
state_after: case left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
H : P.diagonal f
⊢ P.diagonal (e.hom ≫ f)

tactic: rwa [diagonal_iff, pullback.diagonal_comp, hP.cancel_left_isIso, hP.cancel_left_isIso,
  ← hP.cancel_right_isIso _
    (pullback.map (e.hom ≫ f) (e.hom ≫ f) f f e.hom e.hom (𝟙 Z) (by simp) (by simp)),
  ← pullback.condition, hP.cancel_left_isIso]
state_before: case left
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
H : P.diagonal f
⊢ P.diagonal (e.hom ≫ f)
state_after: no goals

tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : X ≅ Y
f : Y ⟶ Z
H : P.diagonal f
⊢ (e.hom ≫ f) ≫ 𝟙 Z = e.hom ≫ f
state_after: no goals

tactic: introv H
state_before: case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y), P.diagonal f → P.diagonal (f ≫ e.hom)
state_after: case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
H : P.diagonal f
⊢ P.diagonal (f ≫ e.hom)

tactic: delta diagonal
state_before: case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
H : P.diagonal f
⊢ P.diagonal (f ≫ e.hom)
state_after: case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
H : P.diagonal f
⊢ P (pullback.diagonal (f ≫ e.hom))

tactic: rwa [pullback.diagonal_comp, hP.cancel_right_isIso]
state_before: case right
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasPullbacks C
P : MorphismProperty C
hP : P.RespectsIso
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
H : P.diagonal f
⊢ P (pullback.diagonal (f ≫ e.hom))
state_after: no goals
Theorem: starConvex_iff_ordConnected
File: Mathlib/Analysis/Convex/Star.lean

tactic: simp_rw [ordConnected_iff_uIcc_subset_left hx, starConvex_iff_segment_subset, segment_eq_uIcc]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝ : LinearOrderedField 𝕜
x : 𝕜
s : Set 𝕜
hx : x ∈ s
⊢ StarConvex 𝕜 x s ↔ s.OrdConnected
state_after: no goals
Theorem: HasFPowerSeriesOnBall.image_sub_sub_deriv_le
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: simpa only [isBigO_principal, mul_assoc, norm_mul, norm_norm, Prod.forall, EMetric.mem_ball,
  Prod.edist_eq, max_lt_iff, and_imp, @forall_swap (_ < _) E] using
  hf.isBigO_image_sub_image_sub_deriv_principal hr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
hf : HasFPowerSeriesOnBall f p x r
hr : r' < r
⊢ ∃ C,
    ∀ y ∈ EMetric.ball x r',
      ∀ z ∈ EMetric.ball x r', ‖f y - f z - (p 1) fun x => y - z‖ ≤ C * max ‖y - x‖ ‖z - x‖ * ‖y - z‖
state_after: no goals
Theorem: Nat.Upto.wf
File: Mathlib/Data/Nat/Upto.lean

tactic: ext ⟨a, ha⟩ ⟨b, _⟩
state_before: p : ℕ → Prop
x : ℕ
h : p x
⊢ Upto.GT p = InvImage (fun x x_1 => x < x_1) fun y => x - ↑y
state_after: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ Upto.GT p ⟨a, ha⟩ ⟨b, property✝⟩ ↔ InvImage (fun x x_1 => x < x_1) (fun y => x - ↑y) ⟨a, ha⟩ ⟨b, property✝⟩

tactic: dsimp [InvImage, Upto.GT]
state_before: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ Upto.GT p ⟨a, ha⟩ ⟨b, property✝⟩ ↔ InvImage (fun x x_1 => x < x_1) (fun y => x - ↑y) ⟨a, ha⟩ ⟨b, property✝⟩
state_after: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ a > b ↔ x - a < x - b

tactic: rw [tsub_lt_tsub_iff_left_of_le (le_of_not_lt fun h' => ha _ h' h)]
state_before: case h.mk.h.mk.a
p : ℕ → Prop
x : ℕ
h : p x
a : ℕ
ha : ∀ j < a, ¬p j
b : ℕ
property✝ : ∀ j < b, ¬p j
⊢ a > b ↔ x - a < x - b
state_after: no goals

tactic: rw [this]
state_before: p : ℕ → Prop
x : ℕ
h : p x
this : Upto.GT p = InvImage (fun x x_1 => x < x_1) fun y => x - ↑y
⊢ WellFounded (Upto.GT p)
state_after: p : ℕ → Prop
x : ℕ
h : p x
this : Upto.GT p = InvImage (fun x x_1 => x < x_1) fun y => x - ↑y
⊢ WellFounded (InvImage (fun x x_1 => x < x_1) fun y => x - ↑y)

tactic: exact (measure _).wf
state_before: p : ℕ → Prop
x : ℕ
h : p x
this : Upto.GT p = InvImage (fun x x_1 => x < x_1) fun y => x - ↑y
⊢ WellFounded (InvImage (fun x x_1 => x < x_1) fun y => x - ↑y)
state_after: no goals
Theorem: FractionalIdeal.coeIdeal_eq_one
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

tactic: simpa only [Ideal.one_eq_top] using coeIdeal_inj
state_before: R : Type u_1
inst✝⁸ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁷ : CommRing P
inst✝⁶ : Algebra R P
loc : IsLocalization S P
K : Type u_3
K' : Type u_4
inst✝⁵ : Field K
inst✝⁴ : Field K'
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I✝ J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
I : Ideal R
⊢ ↑I = 1 ↔ I = 1
state_after: no goals
Theorem: Filter.principal_eq_iff_eq
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [le_antisymm_iff, le_principal_iff, mem_principal]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ 𝓟 s = 𝓟 t ↔ s = t
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ s ⊆ t ∧ t ⊆ s ↔ s ≤ t ∧ t ≤ s

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f g : Filter α
s✝ t✝ s t : Set α
⊢ s ⊆ t ∧ t ⊆ s ↔ s ≤ t ∧ t ≤ s
state_after: no goals
Theorem: Submonoid.mem_iSup_of_mem
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

tactic: rw [← SetLike.le_def]
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
S : ι → Submonoid M
i : ι
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
state_after: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
S : ι → Submonoid M
i : ι
⊢ S i ≤ iSup S

tactic: exact le_iSup _ _
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : MulOneClass M
ι : Sort u_4
S : ι → Submonoid M
i : ι
⊢ S i ≤ iSup S
state_after: no goals
Theorem: Int.preimage_Ioi
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Ioi a = Ioi ⌊a⌋
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioi a ↔ x✝ ∈ Ioi ⌊a⌋

tactic: simp [floor_lt]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioi a ↔ x✝ ∈ Ioi ⌊a⌋
state_after: no goals
Theorem: Matrix.toBilin_basisFun
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: ext M
state_before: R : Type u_1
M : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M
inst✝¹⁵ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
b : Basis n R₂ M₂
⊢ toBilin (Pi.basisFun R₂ n) = toBilin'
state_after: case h.h.h.h.h
R : Type u_1
M✝ : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M✝
inst✝¹⁵ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
b : Basis n R₂ M₂
M : Matrix n n R₂
i✝¹ i✝ : n
⊢ (((toBilin (Pi.basisFun R₂ n)) M ∘ₗ single i✝¹) 1 ∘ₗ single i✝) 1 = ((toBilin' M ∘ₗ single i✝¹) 1 ∘ₗ single i✝) 1

tactic: simp only [coe_comp, coe_single, Function.comp_apply, toBilin_apply, Pi.basisFun_repr,
  toBilin'_apply]
state_before: case h.h.h.h.h
R : Type u_1
M✝ : Type u_2
inst✝¹⁷ : CommSemiring R
inst✝¹⁶ : AddCommMonoid M✝
inst✝¹⁵ : Module R M✝
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁴ : CommRing R₁
inst✝¹³ : AddCommGroup M₁
inst✝¹² : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹¹ : CommSemiring R₂
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝⁸ : CommRing R₃
inst✝⁷ : AddCommGroup M₃
inst✝⁶ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁵ : Field K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
n : Type u_11
o : Type u_12
inst✝² : Fintype n
inst✝¹ : Fintype o
inst✝ : DecidableEq n
b : Basis n R₂ M₂
M : Matrix n n R₂
i✝¹ i✝ : n
⊢ (((toBilin (Pi.basisFun R₂ n)) M ∘ₗ single i✝¹) 1 ∘ₗ single i✝) 1 = ((toBilin' M ∘ₗ single i✝¹) 1 ∘ₗ single i✝) 1
state_after: no goals
Theorem: SetTheory.PGame.neg_birthday
File: Mathlib/SetTheory/Game/Birthday.lean

tactic: rw [birthday_def, birthday_def, max_comm]
state_before: xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
⊢ (-mk xl xr xL xR).birthday = (mk xl xr xL xR).birthday
state_after: xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
⊢ max (lsub fun i => ((-mk xl xr xL xR).moveRight i).birthday) (lsub fun i => ((-mk xl xr xL xR).moveLeft i).birthday) =
    max (lsub fun i => ((mk xl xr xL xR).moveLeft i).birthday) (lsub fun i => ((mk xl xr xL xR).moveRight i).birthday)

tactic: congr <;> funext <;> apply neg_birthday
state_before: xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
⊢ max (lsub fun i => ((-mk xl xr xL xR).moveRight i).birthday) (lsub fun i => ((-mk xl xr xL xR).moveLeft i).birthday) =
    max (lsub fun i => ((mk xl xr xL xR).moveLeft i).birthday) (lsub fun i => ((mk xl xr xL xR).moveRight i).birthday)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.toAffine_addX_of_ne
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: field_simp [mul_ne_zero (mul_ne_zero hPz hQz) hd]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
n d : F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hd : d ≠ 0
⊢ W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2) (n / (P z * Q z * d)) =
    (n ^ 2 + W.a₁ * n * P z * Q z * d - W.a₂ * P z ^ 2 * Q z ^ 2 * d ^ 2 - P x * Q z ^ 2 * d ^ 2 -
        Q x * P z ^ 2 * d ^ 2) /
      (P z * Q z * d) ^ 2
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
n d : F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hd : d ≠ 0
⊢ (((n ^ 2 * (P z * Q z * d) + W.toAffine.a₁ * n * (P z * Q z * d) ^ 2 -
                (P z * Q z * d) ^ 2 * (P z * Q z * d) * W.toAffine.a₂) *
              P z ^ 2 -
            (P z * Q z * d) ^ 2 * (P z * Q z * d) * P x) *
          Q z ^ 2 -
        (P z * Q z * d) ^ 2 * (P z * Q z * d) * P z ^ 2 * Q x) *
      (P z * Q z * d) ^ 2 =
    (n ^ 2 + W.a₁ * n * P z * Q z * d - W.a₂ * P z ^ 2 * Q z ^ 2 * d ^ 2 - P x * Q z ^ 2 * d ^ 2 -
        Q x * P z ^ 2 * d ^ 2) *
      ((P z * Q z * d) ^ 2 * (P z * Q z * d) * P z ^ 2 * Q z ^ 2)

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 → F
n d : F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hd : d ≠ 0
⊢ (((n ^ 2 * (P z * Q z * d) + W.toAffine.a₁ * n * (P z * Q z * d) ^ 2 -
                (P z * Q z * d) ^ 2 * (P z * Q z * d) * W.toAffine.a₂) *
              P z ^ 2 -
            (P z * Q z * d) ^ 2 * (P z * Q z * d) * P x) *
          Q z ^ 2 -
        (P z * Q z * d) ^ 2 * (P z * Q z * d) * P z ^ 2 * Q x) *
      (P z * Q z * d) ^ 2 =
    (n ^ 2 + W.a₁ * n * P z * Q z * d - W.a₂ * P z ^ 2 * Q z ^ 2 * d ^ 2 - P x * Q z ^ 2 * d ^ 2 -
        Q x * P z ^ 2 * d ^ 2) *
      ((P z * Q z * d) ^ 2 * (P z * Q z * d) * P z ^ 2 * Q z ^ 2)
state_after: no goals
Theorem: IsUnit.mul_div_cancel_right
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [div_eq_mul_inv, h.mul_inv_cancel_right]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ a * b / b = a
state_after: no goals
Theorem: VectorFourier.norm_fourierSMulRight
File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

tactic: rw [fourierSMulRight, norm_smul _ (ContinuousLinearMap.smulRight (L v) (f v)),
  norm_neg, norm_mul, norm_mul, norm_eq_abs I, abs_I,
  mul_one, norm_eq_abs ((_ : ℝ) : ℂ), Complex.abs_of_nonneg pi_pos.le, norm_eq_abs (2 : ℂ),
  Complex.abs_two, ContinuousLinearMap.norm_smulRight_apply, ← mul_assoc]
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L✝ : V →L[ℝ] W →L[ℝ] ℝ
f✝ : V → E
L : V →L[ℝ] W →L[ℝ] ℝ
f : V → E
v : V
⊢ ‖fourierSMulRight L f v‖ = 2 * π * ‖L v‖ * ‖f v‖
state_after: no goals
Theorem: div_mul_cancel_of_imp
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: obtain rfl | hb := eq_or_ne b 0 <;>  simp [*]
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m n : ℕ
h : b = 0 → a = 0
⊢ a / b * b = a
state_after: no goals
Theorem: CategoryTheory.CosimplicialObject.σ_comp_σ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: dsimp [δ, σ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.σ i.castSucc ≫ X.σ j = X.σ j.succ ≫ X.σ i
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ i.castSucc) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ j.succ) ≫ X.map (SimplexCategory.σ i)

tactic: simp only [← X.map_comp, SimplexCategory.σ_comp_σ H]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ i.castSucc) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ j.succ) ≫ X.map (SimplexCategory.σ i)
state_after: no goals