1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ContinuousLinearMap.isOpenMap_of_ne_zero
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: continuity
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : f x ≠ 0
y : M
⊢ Continuous fun a => y + (a - f y) • (f x)⁻¹ • x
state_after: no goals

tactic: simp
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : f x ≠ 0
y : M
⊢ (fun a => y + (a - f y) • (f x)⁻¹ • x) (f y) = y
state_after: no goals

tactic: simp [hx]
state_before: R : Type u_1
M : Type u_2
inst✝⁷ : TopologicalSpace R
inst✝⁶ : DivisionRing R
inst✝⁵ : ContinuousSub R
inst✝⁴ : AddCommGroup M
inst✝³ : TopologicalSpace M
inst✝² : ContinuousAdd M
inst✝¹ : Module R M
inst✝ : ContinuousSMul R M
f : M →L[R] R
hf : f ≠ 0
x : M
hx : f x ≠ 0
y : M
a : R
⊢ f ((fun a => y + (a - f y) • (f x)⁻¹ • x) a) = a
state_after: no goals
Theorem: Bool.eq_true_eq_not_eq_false
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: b : Bool
⊢ (¬b = false) = (b = true)
state_after: no goals
Theorem: isTheta_deriv_rpow_const_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: calc deriv (fun (x:ℝ) => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1) := by
            filter_upwards [eventually_ne_atTop 0] with x hx
            rw [Real.deriv_rpow_const (Or.inl hx)]
     _ =Θ[atTop] fun x => x ^ (p-1) :=
            Asymptotics.IsTheta.const_mul_left hp Asymptotics.isTheta_rfl
state_before: f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =Θ[atTop] fun x => x ^ (p - 1)
state_after: no goals

tactic: filter_upwards [eventually_ne_atTop 0] with x hx
state_before: f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1)
state_after: case h
f g : ℝ → ℝ
f' g' x✝ y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x ^ p) x = p * x ^ (p - 1)

tactic: rw [Real.deriv_rpow_const (Or.inl hx)]
state_before: case h
f g : ℝ → ℝ
f' g' x✝ y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x ^ p) x = p * x ^ (p - 1)
state_after: no goals
Theorem: SimpleGraph.IsNClique.map
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: rw [coe_map]
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique ↑(map f s)
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique (⇑f '' ↑s)

tactic: exact h.1.map
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
n : ℕ
s : Finset α
a b c : α
h : G.IsNClique n s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique (⇑f '' ↑s)
state_after: no goals
Theorem: CategoryTheory.epi_iff_inl_eq_inr
File: Mathlib/CategoryTheory/Limits/EpiMono.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f ↔ c.inl = c.inr
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f → c.inl = c.inr

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ c.inl = c.inr → Epi f

tactic: intro hf
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ Epi f → c.inl = c.inr
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : Epi f
⊢ c.inl = c.inr

tactic: simpa only [← cancel_epi f] using c.condition
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : Epi f
⊢ c.inl = c.inr
state_after: no goals

tactic: intro hf
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
⊢ c.inl = c.inr → Epi f
state_after: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
⊢ Epi f

tactic: constructor
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
⊢ Epi f
state_after: case mpr.left_cancellation
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
⊢ ∀ {Z : C} (g h : Y ⟶ Z), f ≫ g = f ≫ h → g = h

tactic: intro Z g g' h
state_before: case mpr.left_cancellation
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
⊢ ∀ {Z : C} (g h : Y ⟶ Z), f ≫ g = f ≫ h → g = h
state_after: case mpr.left_cancellation
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
Z : C
g g' : Y ⟶ Z
h : f ≫ g = f ≫ g'
⊢ g = g'

tactic: obtain ⟨φ, rfl, rfl⟩ := PushoutCocone.IsColimit.desc' hc g g' h
state_before: case mpr.left_cancellation
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
Z : C
g g' : Y ⟶ Z
h : f ≫ g = f ≫ g'
⊢ g = g'
state_after: case mpr.left_cancellation.mk.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
Z : C
φ : c.pt ⟶ Z
h : f ≫ c.inl ≫ φ = f ≫ c.inr ≫ φ
⊢ c.inl ≫ φ = c.inr ≫ φ

tactic: rw [hf]
state_before: case mpr.left_cancellation.mk.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : X ⟶ Y
c : PushoutCocone f f
hc : IsColimit c
hf : c.inl = c.inr
Z : C
φ : c.pt ⟶ Z
h : f ≫ c.inl ≫ φ = f ≫ c.inr ≫ φ
⊢ c.inl ≫ φ = c.inr ≫ φ
state_after: no goals
Theorem: Polynomial.ne_zero_of_mem_rootSet
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rwa [hf, rootSet_zero] at h
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p✝ q : R[X]
inst✝³ : CommRing T
p : T[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
a : S
h : a ∈ p.rootSet S
hf : p = 0
⊢ False
state_after: no goals
Theorem: Real.fourierIntegralInv_eq'
File: Mathlib/Analysis/Fourier/FourierTransform.lean

tactic: simp_rw [fourierIntegralInv_eq, Submonoid.smul_def, Real.fourierChar_apply]
state_before: E : Type u_1
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℂ E
V : Type u_2
inst✝⁹ : NormedAddCommGroup V
inst✝⁸ : InnerProductSpace ℝ V
inst✝⁷ : MeasurableSpace V
inst✝⁶ : BorelSpace V
inst✝⁵ : FiniteDimensional ℝ V
W : Type u_3
inst✝⁴ : NormedAddCommGroup W
inst✝³ : InnerProductSpace ℝ W
inst✝² : MeasurableSpace W
inst✝¹ : BorelSpace W
inst✝ : FiniteDimensional ℝ W
f : V → E
w : V
⊢ 𝓕⁻ f w = ∫ (v : V), Complex.exp (↑(2 * π * ⟪v, w⟫_ℝ) * Complex.I) • f v
state_after: no goals
Theorem: Batteries.AssocList.forM_eq
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

tactic: induction l <;> simp [*, forM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_4
inst✝ : Monad m
f : α → β → m PUnit
l : AssocList α β
⊢ forM f l =
    l.toList.forM fun x =>
      match x with
      | (a, b) => f a b
state_after: no goals
Theorem: LinearPMap.left_le_sup
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: refine ⟨le_sup_left, fun z₁ z₂ hz => ?_⟩
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
⊢ f ≤ f.sup g h
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ = ↑(f.sup g h) z₂

tactic: rw [← add_zero (f _), ← g.map_zero]
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ + ↑g 0 = ↑(f.sup g h) z₂

tactic: refine (sup_apply h _ _ _ ?_).symm
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑f z₁ + ↑g 0 = ↑(f.sup g h) z₂
state_after: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑z₁ + ↑0 = ↑z₂

tactic: simpa
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type u_4
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
h : ∀ (x : ↥f.domain) (y : ↥g.domain), ↑x = ↑y → ↑f x = ↑g y
z₁ : ↥f.domain
z₂ : ↥(f.sup g h).domain
hz : ↑z₁ = ↑z₂
⊢ ↑z₁ + ↑0 = ↑z₂
state_after: no goals
Theorem: Int.natCast_modEq_iff
File: Mathlib/Data/Int/ModEq.lean

tactic: unfold ModEq Nat.ModEq
state_before: m n✝ a✝ b✝ c d : ℤ
a b n : ℕ
⊢ ↑a ≡ ↑b [ZMOD ↑n] ↔ a ≡ b [MOD n]
state_after: m n✝ a✝ b✝ c d : ℤ
a b n : ℕ
⊢ ↑a % ↑n = ↑b % ↑n ↔ a % n = b % n

tactic: rw [← Int.ofNat_inj]
state_before: m n✝ a✝ b✝ c d : ℤ
a b n : ℕ
⊢ ↑a % ↑n = ↑b % ↑n ↔ a % n = b % n
state_after: m n✝ a✝ b✝ c d : ℤ
a b n : ℕ
⊢ ↑a % ↑n = ↑b % ↑n ↔ ↑(a % n) = ↑(b % n)

tactic: simp [natCast_mod]
state_before: m n✝ a✝ b✝ c d : ℤ
a b n : ℕ
⊢ ↑a % ↑n = ↑b % ↑n ↔ ↑(a % n) = ↑(b % n)
state_after: no goals
Theorem: riemannZeta_eulerProduct_hasProd
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

tactic: rw [← tsum_riemannZetaSummand hs]
state_before: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (riemannZeta s)
state_after: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n)

tactic: apply eulerProduct_completely_multiplicative_hasProd <| summable_riemannZetaSummand hs
state_before: s : ℂ
hs : 1 < s.re
⊢ HasProd (fun p => (1 - ↑↑p ^ (-s))⁻¹) (∑' (n : ℕ), (riemannZetaSummandHom ⋯) n)
state_after: no goals
Theorem: Int.ceil_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← ceil_le, ← Int.cast_one, ← Int.cast_sub, ← lt_ceil, Int.sub_one_lt_iff, le_antisymm_iff,
  and_comm]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌈a⌉ = z ↔ ↑z - 1 < a ∧ a ≤ ↑z
state_after: no goals
Theorem: List.rdropWhile_concat_pos
File: Mathlib/Data/List/DropRight.lean

tactic: rw [rdropWhile_concat, if_pos h]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
h : p x = true
⊢ rdropWhile p (l ++ [x]) = rdropWhile p l
state_after: no goals
Theorem: CategoryTheory.Presheaf.isSheaf_comp_of_isSheaf
File: Mathlib/CategoryTheory/Sites/Sheaf.lean

tactic: rw [isSheaf_iff_isLimit] at h ⊢
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
A : Type u₂
inst✝³ : Category.{v₂, u₂} A
A' : Type u₂
inst✝² : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝¹ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
h : IsSheaf J P
⊢ IsSheaf J (P ⋙ s)
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
A : Type u₂
inst✝³ : Category.{v₂, u₂} A
A' : Type u₂
inst✝² : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝¹ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
h : ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (IsLimit (P.mapCone S.arrows.cocone.op))
⊢ ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (IsLimit ((P ⋙ s).mapCone S.arrows.cocone.op))

tactic: apply fun X S hS ↦ (h S hS).map fun t ↦ isLimitOfPreserves s t
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
A : Type u₂
inst✝³ : Category.{v₂, u₂} A
A' : Type u₂
inst✝² : Category.{max v₁ u₁, u₂} A'
B : Type u₃
inst✝¹ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
P : Cᵒᵖ ⥤ A
P' : Cᵒᵖ ⥤ A'
s : A ⥤ B
inst✝ : PreservesLimitsOfSize.{v₁, max v₁ u₁, v₂, v₃, u₂, u₃} s
h : ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (IsLimit (P.mapCone S.arrows.cocone.op))
⊢ ∀ ⦃X : C⦄, ∀ S ∈ J.sieves X, Nonempty (IsLimit ((P ⋙ s).mapCone S.arrows.cocone.op))
state_after: no goals
Theorem: ContinuousLinearMap.inverse_equiv
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: have h : ∃ e' : M ≃L[R] M₂, (e' : M →L[R] M₂) = ↑e := ⟨e, rfl⟩
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
⊢ (↑e).inverse = ↑e.symm
state_after: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ (↑e).inverse = ↑e.symm

tactic: simp only [inverse, dif_pos h]
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ (↑e).inverse = ↑e.symm
state_after: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ ↑(Classical.choose h).symm = ↑e.symm

tactic: congr
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ ↑(Classical.choose h).symm = ↑e.symm
state_after: case e_e.e_e
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ Classical.choose h = e

tactic: exact mod_cast Classical.choose_spec h
state_before: case e_e.e_e
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ Classical.choose h = e
state_after: no goals
Theorem: CoxeterSystem.wordProd_nil
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: simp [wordProd]
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
⊢ cs.wordProd [] = 1
state_after: no goals
Theorem: Finset.sum_centroidWeights_eq_one_of_cast_card_ne_zero
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [h]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
h : ↑s.card ≠ 0
⊢ ∑ i ∈ s, centroidWeights k s i = 1
state_after: no goals
Theorem: Module.eval_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: simpa only using SetLike.ext_iff.mp (eval_ker K V) v
state_before: K : Type uK
V : Type uV
inst✝³ : CommRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : Free K V
v : V
⊢ (eval K V) v = 0 ↔ v = 0
state_after: no goals
Theorem: Sublattice.coe_eq_univ
File: Mathlib/Order/Sublattice.lean

tactic: rw [← coe_top, coe_inj]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f : LatticeHom α β
s t : Set α
a : α
⊢ ↑L = univ ↔ L = ⊤
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.realize_iExs
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [← Formula.realize_iExs, iff_iff_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
inst✝ : Finite γ
f : α → β ⊕ γ
φ : L.Formula α
v : β → M
v' : Fin 0 → M
⊢ Realize (Formula.iExs f φ) v v' ↔ ∃ i, φ.Realize fun a => Sum.elim v i (f a)
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
inst✝ : Finite γ
f : α → β ⊕ γ
φ : L.Formula α
v : β → M
v' : Fin 0 → M
⊢ Realize (Formula.iExs f φ) v v' = (Formula.iExs f φ).Realize v

tactic: congr
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
inst✝ : Finite γ
f : α → β ⊕ γ
φ : L.Formula α
v : β → M
v' : Fin 0 → M
⊢ Realize (Formula.iExs f φ) v v' = (Formula.iExs f φ).Realize v
state_after: case e__xs
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
inst✝ : Finite γ
f : α → β ⊕ γ
φ : L.Formula α
v : β → M
v' : Fin 0 → M
⊢ v' = default

tactic: simp [eq_iff_true_of_subsingleton]
state_before: case e__xs
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝³ : L.Structure M
inst✝² : L.Structure N
inst✝¹ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
T : L.Theory
inst✝ : Finite γ
f : α → β ⊕ γ
φ : L.Formula α
v : β → M
v' : Fin 0 → M
⊢ v' = default
state_after: no goals
Theorem: MeasureTheory.snorm'_le_snorm'_of_exponent_le
File: Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean

tactic: have h_le_μ := snorm'_le_snorm'_mul_rpow_measure_univ hp0_lt hpq hf
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
μ✝ : Measure α
f : α → E
p q : ℝ
hp0_lt : 0 < p
hpq : p ≤ q
μ : Measure α
inst✝ : IsProbabilityMeasure μ
hf : AEStronglyMeasurable f μ
⊢ snorm' f p μ ≤ snorm' f q μ
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
μ✝ : Measure α
f : α → E
p q : ℝ
hp0_lt : 0 < p
hpq : p ≤ q
μ : Measure α
inst✝ : IsProbabilityMeasure μ
hf : AEStronglyMeasurable f μ
h_le_μ : snorm' f p μ ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
⊢ snorm' f p μ ≤ snorm' f q μ

tactic: rwa [measure_univ, ENNReal.one_rpow, mul_one] at h_le_μ
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
μ✝ : Measure α
f : α → E
p q : ℝ
hp0_lt : 0 < p
hpq : p ≤ q
μ : Measure α
inst✝ : IsProbabilityMeasure μ
hf : AEStronglyMeasurable f μ
h_le_μ : snorm' f p μ ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)
⊢ snorm' f p μ ≤ snorm' f q μ
state_after: no goals
Theorem: CategoryTheory.Sieve.generate_of_contains_isSplitEpi
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: rw [← id_mem_iff_eq_top]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
R : Presieve X
f : Y ⟶ X
inst✝ : IsSplitEpi f
hf : R f
⊢ generate R = ⊤
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
R : Presieve X
f : Y ⟶ X
inst✝ : IsSplitEpi f
hf : R f
⊢ (generate R).arrows (𝟙 X)

tactic: exact ⟨_, section_ f, f, hf, by simp⟩
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
R : Presieve X
f : Y ⟶ X
inst✝ : IsSplitEpi f
hf : R f
⊢ (generate R).arrows (𝟙 X)
state_after: no goals

tactic: simp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S R✝ : Sieve X
R : Presieve X
f : Y ⟶ X
inst✝ : IsSplitEpi f
hf : R f
⊢ section_ f ≫ f = 𝟙 X
state_after: no goals
Theorem: CategoryTheory.Limits.ImageMap.mk.injEq'
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp only [Functor.id_obj, eq_iff_iff, iff_true]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ (map = map') = True
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'

tactic: apply ImageMap.map_uniq_aux _ map_ι _ map_ι'
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'
state_after: no goals
Theorem: skyscraperPresheaf_eq_pushforward
File: Mathlib/Topology/Sheaves/Skyscraper.lean

tactic: convert_to @skyscraperPresheaf X p₀ (fun U => hd <| (Opens.map <| ContinuousMap.const _ p₀).obj U)
  C _ _ A = _ <;> congr
state_before: X : TopCat
p₀ : ↑X
inst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)
C : Type v
inst✝¹ : Category.{w, v} C
inst✝ : HasTerminal C
A : C
hd : (U : Opens ↑(of PUnit.{u + 1})) → Decidable (PUnit.unit ∈ U)
⊢ skyscraperPresheaf p₀ A = ContinuousMap.const (↑(of PUnit.{u + 1})) p₀ _* skyscraperPresheaf PUnit.unit A
state_after: no goals