1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: isDedekindDomainInv_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: let h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K :=
  FractionalIdeal.mapEquiv (FractionRing.algEquiv A K)
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
⊢ IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
⊢ IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1

tactic: refine h.toEquiv.forall_congr (fun {x} => ?_)
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
⊢ IsDedekindDomainInv A ↔ ∀ (I : FractionalIdeal A⁰ K), I ≠ ⊥ → I * I⁻¹ = 1
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → x * x⁻¹ = 1 ↔ h.toEquiv x ≠ ⊥ → h.toEquiv x * (h.toEquiv x)⁻¹ = 1

tactic: rw [← h.toEquiv.apply_eq_iff_eq]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → x * x⁻¹ = 1 ↔ h.toEquiv x ≠ ⊥ → h.toEquiv x * (h.toEquiv x)⁻¹ = 1
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → h.toEquiv (x * x⁻¹) = h.toEquiv 1 ↔ h.toEquiv x ≠ ⊥ → h.toEquiv x * (h.toEquiv x)⁻¹ = 1

tactic: simp [h, IsDedekindDomainInv]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Field K
inst✝² : IsDomain A
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
h : FractionalIdeal A⁰ (FractionRing A) ≃+* FractionalIdeal A⁰ K := mapEquiv (FractionRing.algEquiv A K)
x : FractionalIdeal A⁰ (FractionRing A)
⊢ x ≠ ⊥ → h.toEquiv (x * x⁻¹) = h.toEquiv 1 ↔ h.toEquiv x ≠ ⊥ → h.toEquiv x * (h.toEquiv x)⁻¹ = 1
state_after: no goals
Theorem: OpenEmbedding.compatiblePreserving
File: Mathlib/Topology/Sheaves/SheafCondition/Sites.lean

tactic: haveI : Mono f := (TopCat.mono_iff_injective f).mpr hf.inj
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor

tactic: apply compatiblePreservingOfDownwardsClosed
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ CompatiblePreserving (Opens.grothendieckTopology ↑Y) ⋯.functor
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ {c : Opens ↑X} → {d : Opens ↑Y} → (d ⟶ ⋯.functor.obj c) → (c' : Opens ↑X) × (⋯.functor.obj c' ≅ d)

tactic: intro U V i
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
⊢ {c : Opens ↑X} → {d : Opens ↑Y} → (d ⟶ ⋯.functor.obj c) → (c' : Opens ↑X) × (⋯.functor.obj c' ≅ d)
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
⊢ (c' : Opens ↑X) × (⋯.functor.obj c' ≅ V)

tactic: refine ⟨(Opens.map f).obj V, eqToIso <| Opens.ext <| Set.image_preimage_eq_of_subset fun x h ↦ ?_⟩
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
⊢ (c' : Opens ↑X) × (⋯.functor.obj c' ≅ V)
state_after: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
x : ↑Y
h : x ∈ V.1
⊢ x ∈ Set.range ⇑f

tactic: obtain ⟨_, _, rfl⟩ := i.le h
state_before: case hF
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
x : ↑Y
h : x ∈ V.1
⊢ x ∈ Set.range ⇑f
state_after: case hF.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
w✝ : ↑X
left✝ : w✝ ∈ ↑U
h : f w✝ ∈ V.1
⊢ f w✝ ∈ Set.range ⇑f

tactic: exact ⟨_, rfl⟩
state_before: case hF.intro.intro
C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
f : X ⟶ Y
F : TopCat.Presheaf C Y
hf : OpenEmbedding ⇑f
this : Mono f
U : Opens ↑X
V : Opens ↑Y
i : V ⟶ ⋯.functor.obj U
w✝ : ↑X
left✝ : w✝ ∈ ↑U
h : f w✝ ∈ V.1
⊢ f w✝ ∈ Set.range ⇑f
state_after: no goals
Theorem: Complex.imCLM_norm
File: Mathlib/Analysis/Complex/OperatorNorm.lean

tactic: simp
state_before: ⊢ 1 = ‖imCLM I‖
state_after: no goals

tactic: simp
state_before: ⊢ ‖I‖ ≤ 1
state_after: no goals
Theorem: zero_eq_nndist
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [← NNReal.eq_iff, ← dist_nndist, imp_self, NNReal.coe_zero, zero_eq_dist]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
γ : Type w
inst✝ : MetricSpace γ
x y : γ
⊢ 0 = nndist x y ↔ x = y
state_after: no goals
Theorem: Cardinal.ord_injective
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: intro c c' h
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ Injective ord
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c c' : Cardinal.{u_3}
h : c.ord = c'.ord
⊢ c = c'

tactic: rw [← card_ord c, ← card_ord c', h]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c c' : Cardinal.{u_3}
h : c.ord = c'.ord
⊢ c = c'
state_after: no goals
Theorem: mul_lt_iff_lt_one_left'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

tactic: rw [mul_one]
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < a ↔ a * b < a * 1
state_after: no goals
Theorem: ProbabilityTheory.setLIntegral_toKernel_Iic
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

tactic: simp_rw [IsCondKernelCDF.toKernel_Iic]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝ : IsFiniteKernel κ
hf : IsCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ((IsCondKernelCDF.toKernel f hf) (a, b)) (Iic x) ∂ν a = (κ a) (s ×ˢ Iic x)
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝ : IsFiniteKernel κ
hf : IsCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ENNReal.ofReal (↑(f (a, b)) x) ∂ν a = (κ a) (s ×ˢ Iic x)

tactic: exact hf.setLIntegral _ hs _
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝ : IsFiniteKernel κ
hf : IsCondKernelCDF f κ ν
a : α
x : ℝ
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (b : β) in s, ENNReal.ofReal (↑(f (a, b)) x) ∂ν a = (κ a) (s ×ˢ Iic x)
state_after: no goals
Theorem: Set.not_monotoneOn_not_antitoneOn_iff_exists_lt_lt
File: Mathlib/Data/Set/Basic.lean

tactic: simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, and_assoc, exists_and_left,
  not_monotone_not_antitone_iff_exists_lt_lt, @and_left_comm (_ ∈ s)]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
⊢ ¬MonotoneOn f s ∧ ¬AntitoneOn f s ↔
    ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
state_after: no goals
Theorem: Polynomial.roots_multiset_prod_X_sub_C
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [roots_multiset_prod, Multiset.bind_map]
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]
s : Multiset R
⊢ (Multiset.map (fun a => X - C a) s).prod.roots = s
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (s.bind fun a => (X - C a).roots) = s

case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ 0 ∉ Multiset.map (fun a => X - C a) s

tactic: simp_rw [roots_X_sub_C]
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]
s : Multiset R
⊢ (s.bind fun a => (X - C a).roots) = s
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ (s.bind fun a => {a}) = s

tactic: rw [Multiset.bind_singleton, Multiset.map_id']
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]
s : Multiset R
⊢ (s.bind fun a => {a}) = s
state_after: no goals

tactic: rw [Multiset.mem_map]
state_before: case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ 0 ∉ Multiset.map (fun a => X - C a) s
state_after: case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ ¬∃ a ∈ s, X - C a = 0

tactic: rintro ⟨a, -, h⟩
state_before: case a
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
⊢ ¬∃ a ∈ s, X - C a = 0
state_after: case a.intro.intro
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
a : R
h : X - C a = 0
⊢ False

tactic: exact X_sub_C_ne_zero a h
state_before: case a.intro.intro
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Multiset R
a : R
h : X - C a = 0
⊢ False
state_after: no goals
Theorem: String.find_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa using findAux_of_valid p [] s.1 []
state_before: p : Char → Bool
s : String
⊢ s.find p = { byteIdx := utf8Len (List.takeWhile (fun x => !p x) s.data) }
state_after: no goals
Theorem: Function.Antiperiodic.sub_nat_mul_eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [nsmul_eq_mul, zsmul_eq_mul, Int.cast_pow, Int.cast_neg,
  Int.cast_one] using h.sub_nsmul_eq n
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Ring α
inst✝ : Ring β
h : Antiperiodic f c
n : ℕ
⊢ f (x - ↑n * c) = (-1) ^ n * f x
state_after: no goals
Theorem: CategoryTheory.SingleFunctors.inv_hom_id_hom_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

tactic: rw [← NatTrans.comp_app, inv_hom_id_hom, NatTrans.id_app]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.57585, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
e : F ≅ G
n : A
X : C
⊢ (e.inv.hom n).app X ≫ (e.hom.hom n).app X = 𝟙 ((G.functor n).obj X)
state_after: no goals
Theorem: dualTensorHom_prodMap_zero
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: ext <;>
  simp only [coe_comp, coe_inl, Function.comp_apply, prodMap_apply, dualTensorHom_apply,
    fst_apply, Prod.smul_mk, LinearMap.zero_apply, smul_zero]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid N
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
f : Dual R M
p : P
⊢ ((dualTensorHom R M P) (f ⊗ₜ[R] p)).prodMap 0 =
    (dualTensorHom R (M × N) (P × Q)) ((f ∘ₗ fst R M N) ⊗ₜ[R] (inl R P Q) p)
state_after: no goals
Theorem: Basis.orientation_adjustToOrientation
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [adjustToOrientation]
state_before: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (e.adjustToOrientation x).orientation = x
state_after: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (if e.orientation = x then e else e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x

tactic: split_ifs with h
state_before: R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ (if e.orientation = x then e else e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x
state_after: case pos
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : e.orientation = x
⊢ e.orientation = x

case neg
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬e.orientation = x
⊢ (e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x

tactic: exact h
state_before: case pos
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : e.orientation = x
⊢ e.orientation = x
state_after: no goals

tactic: rw [orientation_neg_single, eq_comm, ← orientation_ne_iff_eq_neg, ne_comm]
state_before: case neg
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬e.orientation = x
⊢ (e.unitsSMul (Function.update 1 (Classical.arbitrary ι) (-1))).orientation = x
state_after: case neg
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬e.orientation = x
⊢ e.orientation ≠ x

tactic: exact h
state_before: case neg
R : Type u_1
inst✝⁵ : LinearOrderedCommRing R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
ι : Type u_3
inst✝² : Fintype ι
inst✝¹ : DecidableEq ι
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬e.orientation = x
⊢ e.orientation ≠ x
state_after: no goals
Theorem: Option.map_map₂_antidistrib_left
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_antidistrib]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : β' → α → δ
g' : β → β'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g' b) a
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g' b) a
state_after: no goals
Theorem: sum_geometric_two_le
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have : ∀ i, 0 ≤ (1 / (2 : ℝ)) ^ i := by
  intro i
  apply pow_nonneg
  norm_num
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
⊢ ∑ i ∈ Finset.range n, (1 / 2) ^ i ≤ 2
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ ∑ i ∈ Finset.range n, (1 / 2) ^ i ≤ 2

tactic: convert sum_le_tsum (range n) (fun i _ ↦ this i) summable_geometric_two
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ ∑ i ∈ Finset.range n, (1 / 2) ^ i ≤ 2
state_after: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ 2 = ∑' (i : ℕ), (1 / 2) ^ i

tactic: exact tsum_geometric_two.symm
state_before: case h.e'_4
α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
this : ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
⊢ 2 = ∑' (i : ℕ), (1 / 2) ^ i
state_after: no goals

tactic: intro i
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
n : ℕ
⊢ ∀ (i : ℕ), 0 ≤ (1 / 2) ^ i
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
n i : ℕ
⊢ 0 ≤ (1 / 2) ^ i

tactic: apply pow_nonneg
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
n i : ℕ
⊢ 0 ≤ (1 / 2) ^ i
state_after: case H
α : Type u_1
β : Type u_2
ι : Type u_3
n i : ℕ
⊢ 0 ≤ 1 / 2

tactic: norm_num
state_before: case H
α : Type u_1
β : Type u_2
ι : Type u_3
n i : ℕ
⊢ 0 ≤ 1 / 2
state_after: no goals
Theorem: add_pow_char_pow_of_commute
File: Mathlib/Algebra/CharP/Basic.lean

tactic: let ⟨r, hr⟩ := h.exists_add_pow_prime_pow_eq hp.out n
state_before: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n
state_after: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ↑p * r
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n

tactic: simp [hr]
state_before: R : Type u_1
inst✝¹ : Semiring R
p n : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
x y : R
h : Commute x y
r : R
hr : (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n + ↑p * r
⊢ (x + y) ^ p ^ n = x ^ p ^ n + y ^ p ^ n
state_after: no goals
Theorem: Fin.foldl_eq_foldl_list
File: .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean

tactic: induction n generalizing x with
| zero => rw [foldl_zero, list_zero, List.foldl_nil]
| succ n ih => rw [foldl_succ, ih, list_succ, List.foldl_cons, List.foldl_map]
state_before: α : Type u_1
n : Nat
f : α → Fin n → α
x : α
⊢ foldl n f x = List.foldl f x (list n)
state_after: no goals

tactic: rw [foldl_zero, list_zero, List.foldl_nil]
state_before: case zero
α : Type u_1
f : α → Fin 0 → α
x : α
⊢ foldl 0 f x = List.foldl f x (list 0)
state_after: no goals

tactic: rw [foldl_succ, ih, list_succ, List.foldl_cons, List.foldl_map]
state_before: case succ
α : Type u_1
n : Nat
ih : ∀ (f : α → Fin n → α) (x : α), foldl n f x = List.foldl f x (list n)
f : α → Fin (n + 1) → α
x : α
⊢ foldl (n + 1) f x = List.foldl f x (list (n + 1))
state_after: no goals
Theorem: WeierstrassCurve.leadingCoeff_Φ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

tactic: rw [leadingCoeff, natDegree_Φ, coeff_Φ]
state_before: R : Type u
inst✝¹ : CommRing R
W : WeierstrassCurve R
inst✝ : Nontrivial R
n : ℤ
⊢ (W.Φ n).leadingCoeff = 1
state_after: no goals
Theorem: LinearMap.injective_restrict_iff_disjoint
File: Mathlib/Algebra/Module/Submodule/Ker.lean

tactic: rw [← ker_eq_bot, ker_restrict hf, ker_eq_bot, injective_domRestrict_iff, disjoint_iff]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹¹ : Ring R
inst✝¹⁰ : Ring R₂
inst✝⁹ : Ring R₃
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f✝ : F
p : Submodule R M
f : M →ₗ[R] M
hf : ∀ x ∈ p, f x ∈ p
⊢ Injective ⇑(f.restrict hf) ↔ Disjoint p (ker f)
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.IsUniversal.hom_ext
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: rw [h.hom_desc η, h.hom_desc η', w]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
f g : CostructuredArrow S T
h : f.IsUniversal
c : C
η η' : c ⟶ f.left
w : S.map η ≫ f.hom = S.map η' ≫ f.hom
⊢ η = η'
state_after: no goals
Theorem: CategoryTheory.strict_initial
File: Mathlib/CategoryTheory/Closed/Cartesian.lean

tactic: haveI : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom) := mono_comp _ _
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom)
⊢ IsIso f

tactic: rw [zeroMul_hom, prod.lift_snd] at this
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono (prod.lift (𝟙 A) f ≫ (zeroMul t).hom)
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono f
⊢ IsIso f

tactic: haveI : IsSplitEpi f := IsSplitEpi.mk' ⟨t.to _, t.hom_ext _ _⟩
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this : Mono f
⊢ IsIso f
state_after: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this✝ : Mono f
this : IsSplitEpi f
⊢ IsIso f

tactic: apply isIso_of_mono_of_isSplitEpi
state_before: C : Type u
inst✝² : Category.{v, u} C
A B X X' Y Y' Z : C
inst✝¹ : HasFiniteProducts C
inst✝ : Exponentiable A
I : C
t : IsInitial I
f : A ⟶ I
this✝ : Mono f
this : IsSplitEpi f
⊢ IsIso f
state_after: no goals
Theorem: Real.one_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← sqrt_one, sqrt_le_sqrt_iff' zero_lt_one, sqrt_one]
state_before: x y : ℝ
⊢ 1 ≤ √x ↔ 1 ≤ x
state_after: no goals