1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: String.Iterator.ValidFor.atEnd
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp only [Iterator.atEnd, h.pos, h.toString, endPos_eq, utf8Len_reverseAux, ge_iff_le,
  decide_eq_true_eq]
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ it.atEnd = true ↔ r = []
state_after: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l + utf8Len r ≤ utf8Len l ↔ r = []

tactic: exact Nat.add_le_add_iff_left.trans <| Nat.le_zero.trans utf8Len_eq_zero
state_before: l r : List Char
it : Iterator
h : ValidFor l r it
⊢ utf8Len l + utf8Len r ≤ utf8Len l ↔ r = []
state_after: no goals
Theorem: Real.dimH_univ
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

tactic: rw [dimH_univ_eq_finrank ℝ, FiniteDimensional.finrank_self, Nat.cast_one]
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝⁵ : EMetricSpace X
inst✝⁴ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s t : Set X
E : Type u_4
inst✝³ : Fintype ι
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ dimH univ = 1
state_after: no goals
Theorem: Int.floor_eq_zero_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [floor_eq_iff]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ = 0 ↔ a ∈ Ico 0 1
state_after: no goals
Theorem: Set.sigma_diff_sigma
File: Mathlib/Data/Set/Sigma.lean

tactic: by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ x.1 <;> simp [*, ← imp_iff_or_not]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x✝ : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
x : (i : ι) × α i
⊢ x ∈ s₁.sigma t₁ \ s₂.sigma t₂ ↔ x ∈ s₁.sigma (t₁ \ t₂) ∪ (s₁ \ s₂).sigma t₁
state_after: no goals
Theorem: ZNum.mod_to_int
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← Num.to_nat_to_int, cast_pos, Num.mod_to_nat, ← PosNum.to_nat_to_int, abs_to_nat]
state_before: n : PosNum
d : ZNum
⊢ ↑(Num.pos n % d.abs) = ↑(pos n) % ↑d
state_after: n : PosNum
d : ZNum
⊢ ↑(↑(Num.pos n) % (↑d).natAbs) = ↑↑n % ↑d

tactic: rfl
state_before: n : PosNum
d : ZNum
⊢ ↑(↑(Num.pos n) % (↑d).natAbs) = ↑↑n % ↑d
state_after: no goals

tactic: rw [← Num.to_nat_to_int, cast_neg, ← Num.to_nat_to_int, Num.succ_to_nat, Num.mod_to_nat,
    abs_to_nat, ← Int.subNatNat_eq_coe, n.to_int_eq_succ_pred]
state_before: n : PosNum
d : ZNum
⊢ ↑d.abs - ↑(n.pred' % d.abs).succ = ↑(neg n) % ↑d
state_after: n : PosNum
d : ZNum
⊢ subNatNat (↑d).natAbs (↑n.pred' % (↑d).natAbs + 1) = -(↑↑n.pred' + 1) % ↑d

tactic: rfl
state_before: n : PosNum
d : ZNum
⊢ subNatNat (↑d).natAbs (↑n.pred' % (↑d).natAbs + 1) = -(↑↑n.pred' + 1) % ↑d
state_after: no goals
Theorem: Matroid.base_iff_maximal_indep
File: Mathlib/Data/Matroid/Basic.lean

tactic: refine ⟨fun h ↦ ⟨h.indep, fun _ ↦ h.eq_of_subset_indep ⟩, fun ⟨h, h'⟩ ↦ ?_⟩
state_before: α : Type u_1
M : Matroid α
B : Set α
⊢ M.Base B ↔ M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
state_after: α : Type u_1
M : Matroid α
B : Set α
x✝ : M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
h : M.Indep B
h' : ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
⊢ M.Base B

tactic: obtain ⟨B', hB', hBB'⟩ := h.exists_base_superset
state_before: α : Type u_1
M : Matroid α
B : Set α
x✝ : M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
h : M.Indep B
h' : ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
⊢ M.Base B
state_after: case intro.intro
α : Type u_1
M : Matroid α
B : Set α
x✝ : M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
h : M.Indep B
h' : ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
B' : Set α
hB' : M.Base B'
hBB' : B ⊆ B'
⊢ M.Base B

tactic: rwa [h' _ hB'.indep hBB']
state_before: case intro.intro
α : Type u_1
M : Matroid α
B : Set α
x✝ : M.Indep B ∧ ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
h : M.Indep B
h' : ∀ (I : Set α), M.Indep I → B ⊆ I → B = I
B' : Set α
hB' : M.Base B'
hBB' : B ⊆ B'
⊢ M.Base B
state_after: no goals
Theorem: CategoryTheory.Presieve.Arrows.pullbackCompatible_iff
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

tactic: refine ⟨fun t i j ↦ ?_, fun t i j Z gi gj comm ↦ ?_⟩
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
⊢ Compatible P π x ↔ PullbackCompatible P π x
state_after: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : Compatible P π x
i j : I
⊢ P.map pullback.fst.op (x i) = P.map pullback.snd.op (x j)

case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : PullbackCompatible P π x
i j : I
Z : C
gi : Z ⟶ X i
gj : Z ⟶ X j
comm : gi ≫ π i = gj ≫ π j
⊢ P.map gi.op (x i) = P.map gj.op (x j)

tactic: apply t
state_before: case refine_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : Compatible P π x
i j : I
⊢ P.map pullback.fst.op (x i) = P.map pullback.snd.op (x j)
state_after: case refine_1.a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : Compatible P π x
i j : I
⊢ pullback.fst ≫ π i = pullback.snd ≫ π j

tactic: exact pullback.condition
state_before: case refine_1.a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : Compatible P π x
i j : I
⊢ pullback.fst ≫ π i = pullback.snd ≫ π j
state_after: no goals

tactic: rw [← pullback.lift_fst _ _ comm, op_comp, FunctorToTypes.map_comp_apply, t i j,
  ← FunctorToTypes.map_comp_apply, ← op_comp, pullback.lift_snd]
state_before: case refine_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X✝ Y : C
S : Sieve X✝
R : Presieve X✝
B : C
I : Type u_1
X : I → C
π : (i : I) → X i ⟶ B
inst✝ : (ofArrows X π).hasPullbacks
x : (i : I) → P.obj { unop := X i }
t : PullbackCompatible P π x
i j : I
Z : C
gi : Z ⟶ X i
gj : Z ⟶ X j
comm : gi ≫ π i = gj ≫ π j
⊢ P.map gi.op (x i) = P.map gj.op (x j)
state_after: no goals
Theorem: isSquare_of_charTwo'
File: Mathlib/Algebra/CharP/Reduced.lean

tactic: cases nonempty_fintype R
state_before: R : Type u_1
inst✝³ : Finite R
inst✝² : CommRing R
inst✝¹ : IsReduced R
inst✝ : CharP R 2
a : R
⊢ IsSquare a
state_after: case intro
R : Type u_1
inst✝³ : Finite R
inst✝² : CommRing R
inst✝¹ : IsReduced R
inst✝ : CharP R 2
a : R
val✝ : Fintype R
⊢ IsSquare a

tactic: exact
  Exists.imp (fun b h => pow_two b ▸ Eq.symm h)
    (((Fintype.bijective_iff_injective_and_card _).mpr ⟨frobenius_inj R 2, rfl⟩).surjective a)
state_before: case intro
R : Type u_1
inst✝³ : Finite R
inst✝² : CommRing R
inst✝¹ : IsReduced R
inst✝ : CharP R 2
a : R
val✝ : Fintype R
⊢ IsSquare a
state_after: no goals
Theorem: Matrix.neg_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
⊢ -M * N = -(M * N)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
i✝ : m
j✝ : o
⊢ (-M * N) i✝ j✝ = (-(M * N)) i✝ j✝

tactic: apply neg_dotProduct
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N : Matrix n o α
i✝ : m
j✝ : o
⊢ (-M * N) i✝ j✝ = (-(M * N)) i✝ j✝
state_after: no goals
Theorem: LieAlgebra.coe_rootSpaceWeightSpaceProduct_tmul
File: Mathlib/Algebra/Lie/Weights/Cartan.lean

tactic: simp only [rootSpaceWeightSpaceProduct, rootSpaceWeightSpaceProductAux, coe_liftLie_eq_lift_coe,
  AddHom.toFun_eq_coe, LinearMap.coe_toAddHom, lift_apply, LinearMap.coe_mk, AddHom.coe_mk,
  Submodule.coe_mk]
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : ↥H → R
hχ : χ₁ + χ₂ = χ₃
x : ↥(rootSpace H χ₁)
m : ↥(weightSpace M χ₂)
⊢ ↑((rootSpaceWeightSpaceProduct R L H M χ₁ χ₂ χ₃ hχ) (x ⊗ₜ[R] m)) = ⁅↑x, ↑m⁆
state_after: no goals
Theorem: Batteries.RBNode.zoom_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: rw [← fill_toList, ← zoom_fill eq]
state_before: α : Type u_1
cut : α → Ordering
t' : RBNode α
p' : Path α
t : RBNode α
eq : zoom cut t = (t', p')
⊢ p'.withList t'.toList = t.toList
state_after: α : Type u_1
cut : α → Ordering
t' : RBNode α
p' : Path α
t : RBNode α
eq : zoom cut t = (t', p')
⊢ (root.fill t).toList = t.toList

tactic: rfl
state_before: α : Type u_1
cut : α → Ordering
t' : RBNode α
p' : Path α
t : RBNode α
eq : zoom cut t = (t', p')
⊢ (root.fill t).toList = t.toList
state_after: no goals
Theorem: HurwitzZeta.jacobiTheta₂''_neg_left
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: simp only [jacobiTheta₂'', jacobiTheta₂'_neg_left, jacobiTheta₂_neg_left,
  neg_mul, neg_div, ← neg_add, mul_neg, neg_sq]
state_before: z τ : ℂ
⊢ jacobiTheta₂'' (-z) τ = -jacobiTheta₂'' z τ
state_after: no goals
Theorem: MeasureTheory.Measure.toSphere_apply_aux
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

tactic: rw [← image2_smul, image2_image_right, ← Homeomorph.image_symm, image_image,
  ← image_subtype_val_Ioi_Iio, image2_image_left, image2_swap, ← image_prod]
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ (Subtype.val '' (⇑(homeomorphUnitSphereProd E) ⁻¹' s ×ˢ Iio r)) = μ (Ioo 0 ↑r • Subtype.val '' s)
state_after: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ ((fun x => ↑((homeomorphUnitSphereProd E).symm x)) '' s ×ˢ Iio r) = μ ((fun x => SMul.smul ↑x.2 ↑x.1) '' s ×ˢ Iio r)

tactic: rfl
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ ((fun x => ↑((homeomorphUnitSphereProd E).symm x)) '' s ×ˢ Iio r) = μ ((fun x => SMul.smul ↑x.2 ↑x.1) '' s ×ˢ Iio r)
state_after: no goals
Theorem: FirstOrder.Language.model_nonemptyTheory_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [nonemptyTheory, Theory.model_iff, Set.mem_singleton_iff, forall_eq,
  Sentence.realize_cardGe, Nat.cast_one, one_le_iff_ne_zero, mk_ne_zero_iff]
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
⊢ M ⊨ L.nonemptyTheory ↔ Nonempty M
state_after: no goals
Theorem: GroupTopology.continuous_inv'
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: letI := g.toTopologicalSpace
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
⊢ Continuous Inv.inv
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
this : TopologicalSpace α := g.toTopologicalSpace
⊢ Continuous Inv.inv

tactic: haveI := g.toTopologicalGroup
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
this : TopologicalSpace α := g.toTopologicalSpace
⊢ Continuous Inv.inv
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
this✝ : TopologicalSpace α := g.toTopologicalSpace
this : TopologicalGroup α
⊢ Continuous Inv.inv

tactic: exact continuous_inv
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝ : Group α
g : GroupTopology α
this✝ : TopologicalSpace α := g.toTopologicalSpace
this : TopologicalGroup α
⊢ Continuous Inv.inv
state_after: no goals
Theorem: NormedRing.inverse_add_norm_diff_second_order
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: convert inverse_add_norm_diff_nth_order x 2 using 2
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
⊢ (fun t => inverse (↑x + t) - ↑x⁻¹ + ↑x⁻¹ * t * ↑x⁻¹) =O[𝓝 0] fun t => ‖t‖ ^ 2
state_after: case h.e'_7.h
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
x✝ : R
⊢ inverse (↑x + x✝) - ↑x⁻¹ + ↑x⁻¹ * x✝ * ↑x⁻¹ = inverse (↑x + x✝) - (∑ i ∈ range 2, (-↑x⁻¹ * x✝) ^ i) * ↑x⁻¹

tactic: simp only [sum_range_succ, sum_range_zero, zero_add, pow_zero, pow_one, add_mul, one_mul,
  ← sub_sub, neg_mul, sub_neg_eq_add]
state_before: case h.e'_7.h
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
x : Rˣ
x✝ : R
⊢ inverse (↑x + x✝) - ↑x⁻¹ + ↑x⁻¹ * x✝ * ↑x⁻¹ = inverse (↑x + x✝) - (∑ i ∈ range 2, (-↑x⁻¹ * x✝) ^ i) * ↑x⁻¹
state_after: no goals
Theorem: Ideal.exists_ideal_over_maximal_of_isIntegral
File: Mathlib/RingTheory/Ideal/Over.lean

tactic: obtain ⟨Q, -, Q_prime, hQ⟩ := exists_ideal_over_prime_of_isIntegral P ⊥ hP
state_before: R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
P : Ideal R
P_max : P.IsMaximal
hP : RingHom.ker (algebraMap R S) ≤ P
⊢ ∃ Q, Q.IsMaximal ∧ comap (algebraMap R S) Q = P
state_after: case intro.intro.intro
R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
P : Ideal R
P_max : P.IsMaximal
hP : RingHom.ker (algebraMap R S) ≤ P
Q : Ideal S
Q_prime : Q.IsPrime
hQ : comap (algebraMap R S) Q = P
⊢ ∃ Q, Q.IsMaximal ∧ comap (algebraMap R S) Q = P

tactic: exact ⟨Q, isMaximal_of_isIntegral_of_isMaximal_comap _ (hQ.symm ▸ P_max), hQ⟩
state_before: case intro.intro.intro
R : Type u_1
inst✝³ : CommRing R
S : Type u_2
inst✝² : CommRing S
f : R →+* S
I J : Ideal S
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
P : Ideal R
P_max : P.IsMaximal
hP : RingHom.ker (algebraMap R S) ≤ P
Q : Ideal S
Q_prime : Q.IsPrime
hQ : comap (algebraMap R S) Q = P
⊢ ∃ Q, Q.IsMaximal ∧ comap (algebraMap R S) Q = P
state_after: no goals
Theorem: List.disjoint_pmap
File: Mathlib/Data/List/Basic.lean

tactic: simp only [Disjoint, mem_pmap]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
⊢ (pmap f s hs).Disjoint (pmap f t ht)
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
⊢ ∀ ⦃a : β⦄, (∃ a_1 h, f a_1 ⋯ = a) → (∃ a_2 h, f a_2 ⋯ = a) → False

tactic: rintro b ⟨a, ha, rfl⟩ ⟨a', ha', ha''⟩
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
⊢ ∀ ⦃a : β⦄, (∃ a_1 h, f a_1 ⋯ = a) → (∃ a_2 h, f a_2 ⋯ = a) → False
state_after: case intro.intro.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
a : α
ha : a ∈ s
a' : α
ha' : a' ∈ t
ha'' : f a' ⋯ = f a ⋯
⊢ False

tactic: apply h ha
state_before: case intro.intro.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
a : α
ha : a ∈ s
a' : α
ha' : a' ∈ t
ha'' : f a' ⋯ = f a ⋯
⊢ False
state_after: case intro.intro.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
a : α
ha : a ∈ s
a' : α
ha' : a' ∈ t
ha'' : f a' ⋯ = f a ⋯
⊢ a ∈ t

tactic: rwa [hf a a' (hs a ha) (ht a' ha') ha''.symm]
state_before: case intro.intro.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Prop
f : (a : α) → p a → β
s t : List α
hs : ∀ (a : α), a ∈ s → p a
ht : ∀ (a : α), a ∈ t → p a
hf : ∀ (a a' : α) (ha : p a) (ha' : p a'), f a ha = f a' ha' → a = a'
h : s.Disjoint t
a : α
ha : a ∈ s
a' : α
ha' : a' ∈ t
ha'' : f a' ⋯ = f a ⋯
⊢ a ∈ t
state_after: no goals
Theorem: Real.logb_neg_eq_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← logb_abs x, ← logb_abs (-x), abs_neg]
state_before: b x✝ y x : ℝ
⊢ logb b (-x) = logb b x
state_after: no goals
Theorem: SimpleGraph.Walk.map_snd_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa using congr_arg List.tail (cons_map_snd_darts p)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ List.map (fun x => x.toProd.2) p.darts = p.support.tail
state_after: no goals
Theorem: Complex.sin_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq_add_cos_sq x, add_sub_cancel_right]
state_before: x y : ℂ
⊢ sin x ^ 2 = 1 - cos x ^ 2
state_after: no goals
Theorem: Complex.cos_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [cos]
state_before: x y : ℂ
⊢ cos 0 = 1
state_after: no goals
Theorem: CompTriple.comp_inv
File: Mathlib/Logic/Function/CompTypeclasses.lean

tactic: simp only [IsId.eq_id, h.id]
state_before: M : Type u_1
N : Type u_2
φ : M → N
ψ : N → M
h : Function.RightInverse φ ψ
χ : M → M
inst✝ : IsId χ
⊢ ψ ∘ φ = χ
state_after: no goals
Theorem: CliffordAlgebra.contractRight_mul_algebraMap
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

tactic: rw [← Algebra.commutes, contractRight_algebraMap_mul, Algebra.commutes]
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : CliffordAlgebra Q
r : R
⊢ (contractRight (a * (algebraMap R (CliffordAlgebra Q)) r)) d =
    (contractRight a) d * (algebraMap R (CliffordAlgebra Q)) r
state_after: no goals
Theorem: ENNReal.div_le_iff'
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [mul_comm, ENNReal.div_le_iff h1 h2]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z : ℝ≥0∞
h1 : y ≠ 0
h2 : y ≠ ⊤
⊢ x / y ≤ z ↔ x ≤ y * z
state_after: no goals
Theorem: SetTheory.PGame.Domineering.fst_pred_mem_erase_of_mem_right
File: Mathlib/SetTheory/Game/Domineering.lean

tactic: rw [mem_right] at h
state_before: b : Board
m : ℤ × ℤ
h : m ∈ right b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m

tactic: apply Finset.mem_erase_of_ne_of_mem _ h.2
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ∈ Finset.erase b m
state_after: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ≠ m

tactic: exact ne_of_apply_ne Prod.fst (pred_ne_self m.1)
state_before: b : Board
m : ℤ × ℤ
h : m ∈ b ∧ (m.1 - 1, m.2) ∈ b
⊢ (m.1 - 1, m.2) ≠ m
state_after: no goals
Theorem: Nat.totient_eq_card_lt_and_coprime
File: Mathlib/Data/Nat/Totient.lean

tactic: let e : { m | m < n ∧ n.Coprime m } ≃ Finset.filter n.Coprime (Finset.range n) :=
  { toFun := fun m => ⟨m, by simpa only [Finset.mem_filter, Finset.mem_range] using m.property⟩
    invFun := fun m => ⟨m, by simpa only [Finset.mem_filter, Finset.mem_range] using m.property⟩
    left_inv := fun m => by simp only [Subtype.coe_mk, Subtype.coe_eta]
    right_inv := fun m => by simp only [Subtype.coe_mk, Subtype.coe_eta] }
state_before: n : ℕ
⊢ φ n = Nat.card ↑{m | m < n ∧ n.Coprime m}
state_after: n : ℕ
e : ↑{m | m < n ∧ n.Coprime m} ≃ { x // x ∈ filter n.Coprime (range n) } :=
  { toFun := fun m => ⟨↑m, ⋯⟩, invFun := fun m => ⟨↑m, ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
⊢ φ n = Nat.card ↑{m | m < n ∧ n.Coprime m}

tactic: rw [totient_eq_card_coprime, card_congr e, card_eq_fintype_card, Fintype.card_coe]
state_before: n : ℕ
e : ↑{m | m < n ∧ n.Coprime m} ≃ { x // x ∈ filter n.Coprime (range n) } :=
  { toFun := fun m => ⟨↑m, ⋯⟩, invFun := fun m => ⟨↑m, ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
⊢ φ n = Nat.card ↑{m | m < n ∧ n.Coprime m}
state_after: no goals

tactic: simpa only [Finset.mem_filter, Finset.mem_range] using m.property
state_before: n : ℕ
m : ↑{m | m < n ∧ n.Coprime m}
⊢ ↑m ∈ filter n.Coprime (range n)
state_after: no goals

tactic: simpa only [Finset.mem_filter, Finset.mem_range] using m.property
state_before: n : ℕ
m : { x // x ∈ filter n.Coprime (range n) }
⊢ ↑m ∈ {m | m < n ∧ n.Coprime m}
state_after: no goals

tactic: simp only [Subtype.coe_mk, Subtype.coe_eta]
state_before: n : ℕ
m : ↑{m | m < n ∧ n.Coprime m}
⊢ (fun m => ⟨↑m, ⋯⟩) ((fun m => ⟨↑m, ⋯⟩) m) = m
state_after: no goals

tactic: simp only [Subtype.coe_mk, Subtype.coe_eta]
state_before: n : ℕ
m : { x // x ∈ filter n.Coprime (range n) }
⊢ (fun m => ⟨↑m, ⋯⟩) ((fun m => ⟨↑m, ⋯⟩) m) = m
state_after: no goals
Theorem: mem_selfAdjointMatricesSubmodule'
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: simp only [mem_selfAdjointMatricesSubmodule]
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
inst✝¹ : Fintype n
b : Basis n R₃ M₃
J J₃ A A' : Matrix n n R₃
inst✝ : DecidableEq n
⊢ A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A
state_after: no goals