1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.setIntegral_eq_integral_of_ae_compl_eq_zero
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: symm
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in s, f x ∂μ = ∫ (x : X), f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X), f x ∂μ = ∫ (x : X) in s, f x ∂μ

tactic: nth_rw 1 [← integral_univ]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X), f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in univ, f x ∂μ = ∫ (x : X) in s, f x ∂μ

tactic: apply setIntegral_eq_of_subset_of_ae_diff_eq_zero nullMeasurableSet_univ (subset_univ _)
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∫ (x : X) in univ, f x ∂μ = ∫ (x : X) in s, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∀ᵐ (x : X) ∂μ, x ∈ univ \ s → f x = 0

tactic: filter_upwards [h] with x hx h'x using hx h'x.2
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
h : ∀ᵐ (x : X) ∂μ, x ∉ s → f x = 0
⊢ ∀ᵐ (x : X) ∂μ, x ∈ univ \ s → f x = 0
state_after: no goals
Theorem: isOpenMap_sum_elim
File: Mathlib/Topology/Constructions.lean

tactic: simp only [isOpenMap_sum, elim_inl, elim_inr]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
f : X → Z
g : Y → Z
⊢ IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g
state_after: no goals
Theorem: Real.sign_mul_nonneg
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ 0 ≤ r.sign * r
state_after: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ r.sign * r

case inr.inl

⊢ 0 ≤ sign 0 * 0

case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ r.sign * r

tactic: rw [sign_of_neg hn]
state_before: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ r.sign * r
state_after: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ -1 * r

tactic: exact mul_nonneg_of_nonpos_of_nonpos (by norm_num) hn.le
state_before: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ -1 * r
state_after: no goals

tactic: norm_num
state_before: r : ℝ
hn : r < 0
⊢ -1 ≤ 0
state_after: no goals

tactic: rw [mul_zero]
state_before: case inr.inl

⊢ 0 ≤ sign 0 * 0
state_after: no goals

tactic: rw [sign_of_pos hp, one_mul]
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ r.sign * r
state_after: case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ r

tactic: exact hp.le
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ r
state_after: no goals
Theorem: LinearMap.nilRank_le_finrank
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: simpa only [finrank_eq_card_chooseBasisIndex R M] using nilRank_le_card φ (chooseBasis R M)
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹⁴ : CommRing R
inst✝¹³ : AddCommGroup L
inst✝¹² : Module R L
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁹ : Fintype ι
inst✝⁸ : Fintype ι'
inst✝⁷ : Fintype ιM
inst✝⁶ : DecidableEq ι
inst✝⁵ : DecidableEq ι'
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
b : Basis ι R L
inst✝² : Module.Finite R L
inst✝¹ : Module.Free R L
inst✝ : Nontrivial R
⊢ φ.nilRank ≤ finrank R M
state_after: no goals
Theorem: CategoryTheory.sheafifyMap_sheafifyLift
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

tactic: apply sheafifyLift_unique
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ sheafifyMap J η ≫ sheafifyLift J γ hR = sheafifyLift J (η ≫ γ) hR
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ

tactic: rw [← Category.assoc, ← toSheafify_naturality, Category.assoc, toSheafify_sheafifyLift]
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P Q R : Cᵒᵖ ⥤ D
η : P ⟶ Q
γ : Q ⟶ R
hR : Presheaf.IsSheaf J R
⊢ toSheafify J P ≫ sheafifyMap J η ≫ sheafifyLift J γ hR = η ≫ γ
state_after: no goals
Theorem: LieModule.Weight.ext
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: cases' χ₁ with f₁ _
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : Weight R L M
h : ∀ (x : L), χ₁ x = χ₂ x
⊢ χ₁ = χ₂
state_after: case mk
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₂ : Weight R L M
f₁ : L → R
weightSpace_ne_bot'✝ : weightSpace M f₁ ≠ ⊥
h : ∀ (x : L), { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } x = χ₂ x
⊢ { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } = χ₂

tactic: cases' χ₂ with f₂ _
state_before: case mk
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₂ : Weight R L M
f₁ : L → R
weightSpace_ne_bot'✝ : weightSpace M f₁ ≠ ⊥
h : ∀ (x : L), { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } x = χ₂ x
⊢ { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } = χ₂
state_after: case mk.mk
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
f₁ : L → R
weightSpace_ne_bot'✝¹ : weightSpace M f₁ ≠ ⊥
f₂ : L → R
weightSpace_ne_bot'✝ : weightSpace M f₂ ≠ ⊥
h :
  ∀ (x : L),
    { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝¹ } x =
      { toFun := f₂, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } x
⊢ { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝¹ } =
    { toFun := f₂, weightSpace_ne_bot' := weightSpace_ne_bot'✝ }

tactic: aesop
state_before: case mk.mk
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
f₁ : L → R
weightSpace_ne_bot'✝¹ : weightSpace M f₁ ≠ ⊥
f₂ : L → R
weightSpace_ne_bot'✝ : weightSpace M f₂ ≠ ⊥
h :
  ∀ (x : L),
    { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝¹ } x =
      { toFun := f₂, weightSpace_ne_bot' := weightSpace_ne_bot'✝ } x
⊢ { toFun := f₁, weightSpace_ne_bot' := weightSpace_ne_bot'✝¹ } =
    { toFun := f₂, weightSpace_ne_bot' := weightSpace_ne_bot'✝ }
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.evaluation_aut_injective_of_isConnected
File: Mathlib/CategoryTheory/Galois/Basic.lean

tactic: show Function.Injective ((fun f : A ⟶ A ↦ F.map f a) ∘ (fun f : Aut A ↦ f.hom))
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f.hom a
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ((fun f => F.map f a) ∘ fun f => f.hom)

tactic: apply Function.Injective.comp
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective ((fun f => F.map f a) ∘ fun f => f.hom)
state_after: case hg
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f a

case hf
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => f.hom

tactic: exact evaluation_injective_of_isConnected F A A a
state_before: case hg
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => F.map f a
state_after: no goals

tactic: exact @Aut.ext _ _ A
state_before: case hf
C : Type u₁
inst✝³ : Category.{u₂, u₁} C
inst✝² : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝¹ : FiberFunctor F
A : C
inst✝ : IsConnected A
a : ↑(F.obj A)
⊢ Function.Injective fun f => f.hom
state_after: no goals
Theorem: Module.End.mem_eigenspace_iff
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: rw [eigenspace, LinearMap.mem_ker, LinearMap.sub_apply, algebraMap_end_apply, sub_eq_zero]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
x : M
⊢ x ∈ f.eigenspace μ ↔ f x = μ • x
state_after: no goals
Theorem: RatFunc.liftOn_condition_of_liftOn'_condition
File: Mathlib/FieldTheory/RatFunc/Defs.lean

tactic: rw [h, mul_comm q']
state_before: K : Type u
inst✝ : CommRing K
P : Sort v
f : K[X] → K[X] → P
H : ∀ {p q a : K[X]}, q ≠ 0 → a ≠ 0 → f (a * p) (a * q) = f p q
p q p' q' : K[X]
hq : q ≠ 0
hq' : q' ≠ 0
h : q' * p = q * p'
⊢ f (q' * p) (q' * q) = f (q * p') (q * q')
state_after: no goals
Theorem: Cardinal.aleph0_le_mul_iff'
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: have : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0 := fun a => ne_bot_of_le_ne_bot aleph0_ne_zero a
state_before: α β : Type u
a b : Cardinal.{u}
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0

tactic: simp only [aleph0_le_mul_iff, and_or_left, and_iff_right_of_imp this, @and_left_comm (a ≠ 0)]
state_before: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ b ≠ 0 ∧ ℵ₀ ≤ a ∨ a ≠ 0 ∧ ℵ₀ ≤ b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0

tactic: simp only [and_comm, or_comm]
state_before: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ b ≠ 0 ∧ ℵ₀ ≤ a ∨ a ≠ 0 ∧ ℵ₀ ≤ b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: no goals
Theorem: Units.exists0'
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: simp_rw [val_mk0]
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 : G₀
p : (g : G₀) → g ≠ 0 → Prop
⊢ (∃ g hg, p g hg) ↔ ∃ g hg, p ↑(mk0 g hg) ⋯
state_after: no goals
Theorem: AntitoneOn.mapsTo_Ici
File: Mathlib/Order/Interval/Set/Image.lean

tactic: aesop
state_before: α : Type u_1
β : Type u_2
f : α → β
inst✝¹ : Preorder α
inst✝ : Preorder β
a b : α
h : AntitoneOn f (Ici a)
x✝¹ : α
x✝ : x✝¹ ∈ Ici a
⊢ f x✝¹ ∈ Iic (f a)
state_after: no goals
Theorem: pow_mod_orderOf
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: simp [pow_add, pow_mul, pow_orderOf_eq_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n✝ m : ℕ
x : G
n : ℕ
⊢ x ^ (n % orderOf x) = x ^ (n % orderOf x + orderOf x * (n / orderOf x))
state_after: no goals

tactic: rw [Nat.mod_add_div]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x✝ y : G
n✝ m : ℕ
x : G
n : ℕ
⊢ x ^ (n % orderOf x + orderOf x * (n / orderOf x)) = x ^ n
state_after: no goals
Theorem: CliffordAlgebra.toBaseChange_comp_involute
File: Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean

tactic: ext v
state_before: R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
⊢ (toBaseChange A Q).comp involute = (Algebra.TensorProduct.map (AlgHom.id A A) involute).comp (toBaseChange A Q)
state_after: case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ ((TensorProduct.AlgebraTensorModule.curry
          (((toBaseChange A Q).comp involute).toLinearMap ∘ₗ ι (QuadraticForm.baseChange A Q)))
        1)
      v =
    ((TensorProduct.AlgebraTensorModule.curry
          (((Algebra.TensorProduct.map (AlgHom.id A A) involute).comp (toBaseChange A Q)).toLinearMap ∘ₗ
            ι (QuadraticForm.baseChange A Q)))
        1)
      v

tactic: show toBaseChange A Q (involute (ι (Q.baseChange A) (1 ⊗ₜ[R] v)))
  = (Algebra.TensorProduct.map (AlgHom.id _ _) involute :
      A ⊗[R] CliffordAlgebra Q →ₐ[A] _)
    (toBaseChange A Q (ι (Q.baseChange A) (1 ⊗ₜ[R] v)))
state_before: case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ ((TensorProduct.AlgebraTensorModule.curry
          (((toBaseChange A Q).comp involute).toLinearMap ∘ₗ ι (QuadraticForm.baseChange A Q)))
        1)
      v =
    ((TensorProduct.AlgebraTensorModule.curry
          (((Algebra.TensorProduct.map (AlgHom.id A A) involute).comp (toBaseChange A Q)).toLinearMap ∘ₗ
            ι (QuadraticForm.baseChange A Q)))
        1)
      v
state_after: case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ (toBaseChange A Q) (involute ((ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] v))) =
    (Algebra.TensorProduct.map (AlgHom.id A A) involute)
      ((toBaseChange A Q) ((ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] v)))

tactic: rw [toBaseChange_ι, involute_ι, map_neg (toBaseChange A Q), toBaseChange_ι,
  Algebra.TensorProduct.map_tmul, AlgHom.id_apply, involute_ι, TensorProduct.tmul_neg]
state_before: case a.a.h.h
R : Type u_1
A : Type u_2
V : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : AddCommGroup V
inst✝⁴ : Algebra R A
inst✝³ : Module R V
inst✝² : Module A V
inst✝¹ : IsScalarTower R A V
inst✝ : Invertible 2
Q : QuadraticForm R V
v : V
⊢ (toBaseChange A Q) (involute ((ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] v))) =
    (Algebra.TensorProduct.map (AlgHom.id A A) involute)
      ((toBaseChange A Q) ((ι (QuadraticForm.baseChange A Q)) (1 ⊗ₜ[R] v)))
state_after: no goals
Theorem: WeierstrassCurve.Affine.equation_neg_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rw [equation_iff, equation_iff, negY]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x (W.negY x y) ↔ W.Equation x y
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
      x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ ↔
    y ^ 2 + W.a₁ * x * y + W.a₃ * y = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆

tactic: congr! 1
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
      x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ ↔
    y ^ 2 + W.a₁ * x * y + W.a₃ * y = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆
state_after: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y

tactic: ring1
state_before: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y
state_after: no goals
Theorem: Set.mem_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp [uIcc_eq_union]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ a ∈ [[b, c]] ↔ b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b
state_after: no goals
Theorem: Sym2.card_image_diag
File: Mathlib/Data/Sym/Card.lean

tactic: rw [card_image_of_injOn, diag_card]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ (image Sym2.mk s.diag).card = s.card
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ Set.InjOn Sym2.mk ↑s.diag

tactic: rintro ⟨x₀, x₁⟩ hx _ _ h
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
⊢ Set.InjOn Sym2.mk ↑s.diag
state_after: case mk
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
x₂✝ : α × α
a✝ : x₂✝ ∈ ↑s.diag
h : s(x₀, x₁) = Sym2.mk x₂✝
⊢ (x₀, x₁) = x₂✝

tactic: cases Sym2.eq.1 h
state_before: case mk
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
x₂✝ : α × α
a✝ : x₂✝ ∈ ↑s.diag
h : s(x₀, x₁) = Sym2.mk x₂✝
⊢ (x₀, x₁) = x₂✝
state_after: case mk.refl
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx a✝ : (x₀, x₁) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₀, x₁)
⊢ (x₀, x₁) = (x₀, x₁)

case mk.swap
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
a✝ : (x₁, x₀) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₁, x₀)
⊢ (x₀, x₁) = (x₁, x₀)

tactic: rfl
state_before: case mk.refl
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx a✝ : (x₀, x₁) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₀, x₁)
⊢ (x₀, x₁) = (x₀, x₁)
state_after: no goals

tactic: simp only [mem_coe, mem_diag] at hx
state_before: case mk.swap
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
hx : (x₀, x₁) ∈ ↑s.diag
a✝ : (x₁, x₀) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₁, x₀)
⊢ (x₀, x₁) = (x₁, x₀)
state_after: case mk.swap
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
a✝ : (x₁, x₀) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₁, x₀)
hx : x₀ ∈ s ∧ x₀ = x₁
⊢ (x₀, x₁) = (x₁, x₀)

tactic: rw [hx.2]
state_before: case mk.swap
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s : Finset α
x₀ x₁ : α
a✝ : (x₁, x₀) ∈ ↑s.diag
h : s(x₀, x₁) = s(x₁, x₀)
hx : x₀ ∈ s ∧ x₀ = x₁
⊢ (x₀, x₁) = (x₁, x₀)
state_after: no goals
Theorem: Multiset.bind_congr
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp (config := { contextual := true }) [bind]
state_before: α : Type u_1
β : Type v
γ : Type u_2
δ : Type u_3
a : α
s t : Multiset α
f✝ g✝ f g : α → Multiset β
m : Multiset α
⊢ (∀ a ∈ m, f a = g a) → m.bind f = m.bind g
state_after: no goals
Theorem: Topology.IsScottHausdorff.dirSupInacc_of_isOpen
File: Mathlib/Topology/Order/ScottTopology.lean

tactic: obtain ⟨b, hbd, hb⟩ := isOpen_iff.1 h hd₁ hd₂ hda hd₃
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : IsScottHausdorff α
s : Set α
h : IsOpen s
d : Set α
hd₁ : d.Nonempty
hd₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
hd₃ : a ∈ s
⊢ (d ∩ s).Nonempty
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : IsScottHausdorff α
s : Set α
h : IsOpen s
d : Set α
hd₁ : d.Nonempty
hd₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
hd₃ : a ∈ s
b : α
hbd : b ∈ d
hb : Ici b ∩ d ⊆ s
⊢ (d ∩ s).Nonempty

tactic: exact ⟨b, hbd, hb ⟨le_rfl, hbd⟩⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
s✝ : Set α
inst✝¹ : TopologicalSpace α
inst✝ : IsScottHausdorff α
s : Set α
h : IsOpen s
d : Set α
hd₁ : d.Nonempty
hd₂ : DirectedOn (fun x x_1 => x ≤ x_1) d
a : α
hda : IsLUB d a
hd₃ : a ∈ s
b : α
hbd : b ∈ d
hb : Ici b ∩ d ⊆ s
⊢ (d ∩ s).Nonempty
state_after: no goals
Theorem: List.modifyNth_eq_set_get
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [modifyNth_eq_set_get?, get?_eq_get h]
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ modifyNth f n l = l.set n (f (l.get ⟨n, h⟩))
state_after: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ ((fun a => l.set n (f a)) <$> some (l.get ⟨n, h⟩)).getD l = l.set n (f (l.get ⟨n, h⟩))

tactic: rfl
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
h : n < l.length
⊢ ((fun a => l.set n (f a)) <$> some (l.get ⟨n, h⟩)).getD l = l.set n (f (l.get ⟨n, h⟩))
state_after: no goals
Theorem: WithSeminorms.mem_nhds_iff
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [hp.hasBasis_ball.mem_iff, Prod.exists]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕝 : Type u_3
𝕝₂ : Type u_4
E : Type u_5
F : Type u_6
G : Type u_7
ι : Type u_8
ι' : Type u_9
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
inst✝ : TopologicalSpace E
p : SeminormFamily 𝕜 E ι
hp : WithSeminorms p
x : E
U : Set E
⊢ U ∈ 𝓝 x ↔ ∃ s, ∃ r > 0, (s.sup p).ball x r ⊆ U
state_after: no goals