1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: union_mem_nhdsSet
File: Mathlib/Topology/NhdsSet.lean

tactic: rw [nhdsSet_union]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h₁ : s₁ ∈ 𝓝ˢ t₁
h₂ : s₂ ∈ 𝓝ˢ t₂
⊢ s₁ ∪ s₂ ∈ 𝓝ˢ (t₁ ∪ t₂)
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h₁ : s₁ ∈ 𝓝ˢ t₁
h₂ : s₂ ∈ 𝓝ˢ t₂
⊢ s₁ ∪ s₂ ∈ 𝓝ˢ t₁ ⊔ 𝓝ˢ t₂

tactic: exact union_mem_sup h₁ h₂
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f : Filter X
s t s₁ s₂ t₁ t₂ : Set X
x : X
h₁ : s₁ ∈ 𝓝ˢ t₁
h₂ : s₂ ∈ 𝓝ˢ t₂
⊢ s₁ ∪ s₂ ∈ 𝓝ˢ t₁ ⊔ 𝓝ˢ t₂
state_after: no goals
Theorem: Subgroup.coe_transferFunction
File: Mathlib/GroupTheory/Complement.lean

tactic: rw [transferFunction_apply, ← smul_eq_mul, Quotient.coe_smul_out',
  ← quotientEquivSigmaZMod_symm_apply, Sigma.eta, symm_apply_apply]
state_before: G : Type u
inst✝ : Group G
H : Subgroup G
g : G
q : G ⧸ H
⊢ ↑(H.transferFunction g q) = q
state_after: no goals
Theorem: List.prefix_iff_eq_append
File: Mathlib/Data/List/Infix.lean

tactic: rintro ⟨r, rfl⟩
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ l₁ <+: l₂ → l₁ ++ drop l₁.length l₂ = l₂
state_after: case intro
α : Type u_1
β : Type u_2
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ l₁ ++ drop l₁.length (l₁ ++ r) = l₁ ++ r

tactic: rw [drop_left]
state_before: case intro
α : Type u_1
β : Type u_2
l l₁ l₃ : List α
a b : α
m n : ℕ
r : List α
⊢ l₁ ++ drop l₁.length (l₁ ++ r) = l₁ ++ r
state_after: no goals
Theorem: IsPerfectClosure.equiv_symm_apply
File: Mathlib/FieldTheory/IsPerfectClosure.lean

tactic: rw [equiv_symm, equiv_apply j i p _ _ _ h]
state_before: K : Type u_1
L : Type u_2
M : Type u_3
N : Type u_4
inst✝¹¹ : CommRing K
inst✝¹⁰ : CommRing L
inst✝⁹ : CommRing M
inst✝⁸ : CommRing N
i : K →+* L
j : K →+* M
k : K →+* N
f : L →+* M
g : L →+* N
p : ℕ
inst✝⁷ : ExpChar K p
inst✝⁶ : ExpChar L p
inst✝⁵ : ExpChar M p
inst✝⁴ : ExpChar N p
inst✝³ : PerfectRing L p
inst✝² : IsPerfectClosure i p
inst✝¹ : PerfectRing M p
inst✝ : IsPerfectClosure j p
x : M
n : ℕ
y : K
h : j y = x ^ p ^ n
⊢ (equiv i j p).symm x = (iterateFrobeniusEquiv L p n).symm (i y)
state_after: no goals
Theorem: MvPolynomial.totalDegree_X_pow
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: simp [X_pow_eq_monomial, one_ne_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ (X s ^ n).totalDegree = n
state_after: no goals
Theorem: Finset.image₂_def
File: Mathlib/Data/Finset/Functor.lean

tactic: ext
state_before: α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
⊢ image₂ f s t = Seq.seq (f <$> s) fun x => t
state_after: case a
α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
a✝ : γ
⊢ a✝ ∈ image₂ f s t ↔ a✝ ∈ Seq.seq (f <$> s) fun x => t

tactic: simp [mem_sup]
state_before: case a
α✝ β✝ : Type u
inst✝ : (P : Prop) → Decidable P
α β γ : Type u
f : α → β → γ
s : Finset α
t : Finset β
a✝ : γ
⊢ a✝ ∈ image₂ f s t ↔ a✝ ∈ Seq.seq (f <$> s) fun x => t
state_after: no goals
Theorem: CategoryTheory.ColimitAdj.restrictYonedaHomEquiv_natural
File: Mathlib/CategoryTheory/Limits/Presheaf.lean

tactic: ext x X
state_before: C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P : Cᵒᵖ ⥤ Type u₁
E₁ E₂ : ℰ
g : E₁ ⟶ E₂
c : Cocone ((CategoryOfElements.π P).leftOp ⋙ A)
t : IsColimit c
k : c.pt ⟶ E₁
⊢ (restrictYonedaHomEquiv A P E₂ t) (k ≫ g) = (restrictYonedaHomEquiv A P E₁ t) k ≫ (restrictedYoneda A).map g
state_after: case w.h.h
C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P : Cᵒᵖ ⥤ Type u₁
E₁ E₂ : ℰ
g : E₁ ⟶ E₂
c : Cocone ((CategoryOfElements.π P).leftOp ⋙ A)
t : IsColimit c
k : c.pt ⟶ E₁
x : Cᵒᵖ
X : P.obj x
⊢ ((restrictYonedaHomEquiv A P E₂ t) (k ≫ g)).app x X =
    ((restrictYonedaHomEquiv A P E₁ t) k ≫ (restrictedYoneda A).map g).app x X

tactic: apply (assoc _ _ _).symm
state_before: case w.h.h
C : Type u₁
inst✝¹ : SmallCategory C
ℰ : Type u₂
inst✝ : Category.{u₁, u₂} ℰ
A : C ⥤ ℰ
P : Cᵒᵖ ⥤ Type u₁
E₁ E₂ : ℰ
g : E₁ ⟶ E₂
c : Cocone ((CategoryOfElements.π P).leftOp ⋙ A)
t : IsColimit c
k : c.pt ⟶ E₁
x : Cᵒᵖ
X : P.obj x
⊢ ((restrictYonedaHomEquiv A P E₂ t) (k ≫ g)).app x X =
    ((restrictYonedaHomEquiv A P E₁ t) k ≫ (restrictedYoneda A).map g).app x X
state_after: no goals
Theorem: TopologicalSpace.Opens.partialHomeomorphSubtypeCoe_target
File: Mathlib/Topology/PartialHomeomorph.lean

tactic: simp only [partialHomeomorphSubtypeCoe, Subtype.range_coe_subtype, mfld_simps]
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
s : Opens X
hs : Nonempty ↥s
⊢ (s.partialHomeomorphSubtypeCoe hs).target = ↑s
state_after: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
s : Opens X
hs : Nonempty ↥s
⊢ {x | x ∈ s.carrier} = ↑s

tactic: rfl
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
s : Opens X
hs : Nonempty ↥s
⊢ {x | x ∈ s.carrier} = ↑s
state_after: no goals
Theorem: CategoryTheory.Quotient.compClosure_iff_self
File: Mathlib/CategoryTheory/Quotient.lean

tactic: constructor
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
⊢ CompClosure r f g ↔ r f g
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
⊢ CompClosure r f g → r f g

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
⊢ r f g → CompClosure r f g

tactic: intro hfg
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
⊢ CompClosure r f g → r f g
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
hfg : CompClosure r f g
⊢ r f g

tactic: induction' hfg with m m' hm
state_before: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
hfg : CompClosure r f g
⊢ r f g
state_after: case mp.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
m m' : C
hm : X ⟶ m
m₁✝ m₂✝ : m ⟶ m'
g✝ : m' ⟶ Y
h✝ : r m₁✝ m₂✝
⊢ r (hm ≫ m₁✝ ≫ g✝) (hm ≫ m₂✝ ≫ g✝)

tactic: exact Congruence.compLeft _ (Congruence.compRight _ (by assumption))
state_before: case mp.intro
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
m m' : C
hm : X ⟶ m
m₁✝ m₂✝ : m ⟶ m'
g✝ : m' ⟶ Y
h✝ : r m₁✝ m₂✝
⊢ r (hm ≫ m₁✝ ≫ g✝) (hm ≫ m₂✝ ≫ g✝)
state_after: no goals

tactic: assumption
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
m m' : C
hm : X ⟶ m
m₁✝ m₂✝ : m ⟶ m'
g✝ : m' ⟶ Y
h✝ : r m₁✝ m₂✝
⊢ r m₁✝ m₂✝
state_after: no goals

tactic: exact CompClosure.of _ _ _
state_before: case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
r : HomRel C
h : Congruence r
X Y : C
f g : X ⟶ Y
⊢ r f g → CompClosure r f g
state_after: no goals
Theorem: Behrend.norm_of_mem_sphere
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

tactic: rw [EuclideanSpace.norm_eq]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x)‖ = √↑k
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x) i‖ ^ 2) = √↑k

tactic: dsimp
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, ‖(WithLp.equiv 2 (Fin n → ℝ)).symm (Nat.cast ∘ x) i‖ ^ 2) = √↑k
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, |↑(x i)| ^ 2) = √↑k

tactic: simp_rw [abs_cast, ← cast_pow, ← cast_sum, (mem_filter.1 hx).2]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x✝ x : Fin n → ℕ
hx : x ∈ sphere n d k
⊢ √(∑ i : Fin n, |↑(x i)| ^ 2) = √↑k
state_after: no goals
Theorem: List.modifyNthTail_modifyNthTail_le
File: Mathlib/Data/List/Basic.lean

tactic: rcases Nat.exists_eq_add_of_le h with ⟨m, rfl⟩
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
m n : ℕ
l : List α
h : n ≤ m
⊢ modifyNthTail g m (modifyNthTail f n l) = modifyNthTail (fun l => modifyNthTail g (m - n) (f l)) n l
state_after: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
n : ℕ
l : List α
m : ℕ
h : n ≤ n + m
⊢ modifyNthTail g (n + m) (modifyNthTail f n l) = modifyNthTail (fun l => modifyNthTail g (n + m - n) (f l)) n l

tactic: rw [Nat.add_comm, modifyNthTail_modifyNthTail, Nat.add_sub_cancel]
state_before: case intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f g : List α → List α
n : ℕ
l : List α
m : ℕ
h : n ≤ n + m
⊢ modifyNthTail g (n + m) (modifyNthTail f n l) = modifyNthTail (fun l => modifyNthTail g (n + m - n) (f l)) n l
state_after: no goals
Theorem: FirstOrder.Language.DirectLimit.exists_of
File: Mathlib/ModelTheory/DirectLimit.lean

tactic: simp
state_before: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
z : DirectLimit G f
⊢ (of L ι G f (Quotient.out z).fst) (Quotient.out z).snd = z
state_after: no goals
Theorem: eq_nnratCast
File: Mathlib/Data/Rat/Cast/Defs.lean

tactic: rw [← map_nnratCast f, NNRat.cast_id]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝³ : FunLike F α β
inst✝² : DivisionSemiring α
inst✝¹ : FunLike F ℚ≥0 α
inst✝ : RingHomClass F ℚ≥0 α
f : F
q : ℚ≥0
⊢ f q = ↑q
state_after: no goals
Theorem: Polynomial.derivative_intCast_mul
File: Mathlib/Algebra/Polynomial/Derivative.lean

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : Ring R
n : ℤ
f : R[X]
⊢ derivative (↑n * f) = ↑n * derivative f
state_after: no goals
Theorem: Set.subset_ite
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [subset_def, ← forall_and]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ t s s' u : Set α
⊢ u ⊆ t.ite s s' ↔ u ∩ t ⊆ s ∧ u \ t ⊆ s'
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ t s s' u : Set α
⊢ (∀ x ∈ u, x ∈ t.ite s s') ↔ ∀ (x : α), (x ∈ u ∩ t → x ∈ s) ∧ (x ∈ u \ t → x ∈ s')

tactic: refine forall_congr' fun x => ?_
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ t s s' u : Set α
⊢ (∀ x ∈ u, x ∈ t.ite s s') ↔ ∀ (x : α), (x ∈ u ∩ t → x ∈ s) ∧ (x ∈ u \ t → x ∈ s')
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ t s s' u : Set α
x : α
⊢ x ∈ u → x ∈ t.ite s s' ↔ (x ∈ u ∩ t → x ∈ s) ∧ (x ∈ u \ t → x ∈ s')

tactic: by_cases hx : x ∈ t <;> simp [*, Set.ite]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u✝ t s s' u : Set α
x : α
⊢ x ∈ u → x ∈ t.ite s s' ↔ (x ∈ u ∩ t → x ∈ s) ∧ (x ∈ u \ t → x ∈ s')
state_after: no goals
Theorem: ENNReal.log_of_nnreal
File: Mathlib/Analysis/SpecialFunctions/Log/ENNReal.lean

tactic: simp [log, h]
state_before: x : ℝ≥0
h : x ≠ 0
⊢ (↑x).log = ↑(Real.log ↑x)
state_after: no goals
Theorem: IsPrimitiveRoot.coe_units_iff
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: simp only [iff_def, Units.ext_iff, Units.val_pow_eq_pow_val, Units.val_one]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ✝ : M
f : F
h : IsPrimitiveRoot ζ✝ k
ζ : Mˣ
⊢ IsPrimitiveRoot (↑ζ) k ↔ IsPrimitiveRoot ζ k
state_after: no goals
Theorem: RatFunc.num_denom_mul
File: Mathlib/FieldTheory/RatFunc/Basic.lean

tactic: conv_lhs =>
  rw [← num_div_denom x, ← num_div_denom y, div_mul_div_comm, ← RingHom.map_mul, ←
    RingHom.map_mul]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = (algebraMap K[X] (RatFunc K)) (x.num * y.num) / (algebraMap K[X] (RatFunc K)) (x.denom * y.denom)
state_after: no goals
Theorem: MulAction.mem_stabilizer_finset
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

tactic: simp_rw [← stabilizer_coe_finset, mem_stabilizer_set, Finset.mem_coe]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
inst✝³ : Group G
inst✝² : Group H
inst✝¹ : MulAction G α
a : G
inst✝ : DecidableEq α
s : Finset α
⊢ a ∈ stabilizer G s ↔ ∀ (b : α), a • b ∈ s ↔ b ∈ s
state_after: no goals
Theorem: PMF.toOuterMeasure_caratheodory
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: refine eq_top_iff.2 <| le_trans (le_sInf fun x hx => ?_) (le_sum_caratheodory _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
⊢ p.toOuterMeasure.caratheodory = ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
⊢ ⊤ ≤ x

tactic: have ⟨y, hy⟩ := hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
⊢ ⊤ ≤ x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
y : α
hy : (fun i => (p i • dirac i).caratheodory) y = x
⊢ ⊤ ≤ x

tactic: exact
  ((le_of_eq (dirac_caratheodory y).symm).trans (le_smul_caratheodory _ _)).trans (le_of_eq hy)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
s t : Set α
x : MeasurableSpace α
hx : x ∈ Set.range fun i => (p i • dirac i).caratheodory
y : α
hy : (fun i => (p i • dirac i).caratheodory) y = x
⊢ ⊤ ≤ x
state_after: no goals
Theorem: MeasureTheory.LipschitzWith.integrable_comp_iff_of_antilipschitz
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [← memℒp_one_iff_integrable, hg.memℒp_comp_iff_of_antilipschitz hg' g0]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
K K' : ℝ≥0
f : α → β
g : β → γ
hg : LipschitzWith K g
hg' : AntilipschitzWith K' g
g0 : g 0 = 0
⊢ Integrable (g ∘ f) μ ↔ Integrable f μ
state_after: no goals
Theorem: inf_eq_left
File: Mathlib/Order/Lattice.lean

tactic: simp [le_rfl]
state_before: α : Type u
β : Type v
inst✝ : SemilatticeInf α
a b c d : α
⊢ a ⊓ b ≤ a ∧ a ≤ a ⊓ b ↔ a ≤ b
state_after: no goals
Theorem: Set.bijOn_singleton
File: Mathlib/Data/Set/Function.lean

tactic: simp [BijOn, eq_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ BijOn f {a} {b} ↔ f a = b
state_after: no goals
Theorem: Int.cast_subNatNat
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: unfold subNatNat
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(subNatNat m n) = ↑m - ↑n
state_after: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(match n - m with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n

tactic: cases e : n - m
state_before: R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
⊢ ↑(match n - m with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n
state_after: case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = 0
⊢ ↑(match 0 with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n

case succ
R : Type u
inst✝ : AddGroupWithOne R
m n n✝ : ℕ
e : n - m = n✝ + 1
⊢ ↑(match n✝ + 1 with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n

tactic: simp only [ofNat_eq_coe]
state_before: case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = 0
⊢ ↑(match 0 with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n
state_after: case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = 0
⊢ ↑↑(m - n) = ↑m - ↑n

tactic: simp [e, Nat.le_of_sub_eq_zero e]
state_before: case zero
R : Type u
inst✝ : AddGroupWithOne R
m n : ℕ
e : n - m = 0
⊢ ↑↑(m - n) = ↑m - ↑n
state_after: no goals

tactic: rw [cast_negSucc, ← e, Nat.cast_sub <| _root_.le_of_lt <| Nat.lt_of_sub_eq_succ e, neg_sub]
state_before: case succ
R : Type u
inst✝ : AddGroupWithOne R
m n n✝ : ℕ
e : n - m = n✝ + 1
⊢ ↑(match n✝ + 1 with
      | 0 => ofNat (m - n)
      | k.succ => -[k+1]) =
    ↑m - ↑n
state_after: no goals
Theorem: riemannZeta_neg_nat_eq_bernoulli
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

tactic: rw [riemannZeta_neg_nat_eq_bernoulli', bernoulli, Rat.cast_mul, Rat.cast_pow, Rat.cast_neg,
  Rat.cast_one, ← neg_one_mul, ← mul_assoc, pow_succ, ← mul_assoc, ← mul_pow, neg_one_mul (-1),
  neg_neg, one_pow, one_mul]
state_before: k : ℕ
⊢ riemannZeta (-↑k) = (-1) ^ k * ↑(bernoulli (k + 1)) / (↑k + 1)
state_after: no goals
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₂₀_iff'
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

tactic: rintro ⟨⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₂ c) (in₀ a) → ∃ x ∈ t, x.2.2 = c ∧ x.1 = a
state_after: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ x ∈ t, x.2.2 = c ∧ x.1 = a

tactic: exact ⟨_, ‹_›, by simp⟩
state_before: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ x ∈ t, x.2.2 = c ∧ x.1 = a
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ (a, b✝, c).2.2 = c ∧ (a, b✝, c).1 = a
state_after: no goals

tactic: rintro ⟨⟨a, b, c⟩, h, rfl, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (∃ x ∈ t, x.2.2 = c ∧ x.1 = a) → (graph t).Adj (in₂ c) (in₀ a)
state_after: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₂ (a, b, c).2.2) (in₀ (a, b, c).1)

tactic: constructor
state_before: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₂ (a, b, c).2.2) (in₀ (a, b, c).1)
state_after: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, ?intro.mk.mk.intro.intro.b, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.b
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ β

tactic: assumption
state_before: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, ?intro.mk.mk.intro.intro.b, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.b
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ β
state_after: no goals
Theorem: Real.arctan_add_arctan_lt_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: cases' le_or_lt y 0 with hy hy
state_before: x y : ℝ
h : x * y < 1
⊢ arctan x + arctan y < π / 2
state_after: case inl
x y : ℝ
h : x * y < 1
hy : y ≤ 0
⊢ arctan x + arctan y < π / 2

case inr
x y : ℝ
h : x * y < 1
hy : 0 < y
⊢ arctan x + arctan y < π / 2

tactic: rw [← add_zero (π / 2), ← arctan_zero]
state_before: case inl
x y : ℝ
h : x * y < 1
hy : y ≤ 0
⊢ arctan x + arctan y < π / 2
state_after: case inl
x y : ℝ
h : x * y < 1
hy : y ≤ 0
⊢ arctan x + arctan y < π / 2 + arctan 0

tactic: exact add_lt_add_of_lt_of_le (arctan_lt_pi_div_two _) (tanOrderIso.symm.monotone hy)
state_before: case inl
x y : ℝ
h : x * y < 1
hy : y ≤ 0
⊢ arctan x + arctan y < π / 2 + arctan 0
state_after: no goals

tactic: rw [← lt_div_iff hy, ← inv_eq_one_div] at h
state_before: case inr
x y : ℝ
h : x * y < 1
hy : 0 < y
⊢ arctan x + arctan y < π / 2
state_after: case inr
x y : ℝ
h : x < y⁻¹
hy : 0 < y
⊢ arctan x + arctan y < π / 2

tactic: replace h : arctan x < arctan y⁻¹ := tanOrderIso.symm.strictMono h
state_before: case inr
x y : ℝ
h : x < y⁻¹
hy : 0 < y
⊢ arctan x + arctan y < π / 2
state_after: case inr
x y : ℝ
hy : 0 < y
h : arctan x < arctan y⁻¹
⊢ arctan x + arctan y < π / 2

tactic: rwa [arctan_inv_of_pos hy, lt_tsub_iff_right] at h
state_before: case inr
x y : ℝ
hy : 0 < y
h : arctan x < arctan y⁻¹
⊢ arctan x + arctan y < π / 2
state_after: no goals
Theorem: PartialHomeomorph.map_extend_nhds_of_boundaryless
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [f.map_extend_nhds _ hx, I.range_eq_univ, nhdsWithin_univ]
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁴ : NormedAddCommGroup E'
inst✝³ : NormedSpace 𝕜 E'
inst✝² : TopologicalSpace H'
inst✝¹ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝ : I.Boundaryless
x : M
hx : x ∈ f.source
⊢ map (↑(f.extend I)) (𝓝 x) = 𝓝 (↑(f.extend I) x)
state_after: no goals
Theorem: Polynomial.map_smul
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [map, eval₂_smul, RingHom.comp_apply, C_mul']
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : Semiring S
f : R →+* S
r : R
⊢ map f (r • p) = f r • map f p
state_after: no goals
Theorem: minpoly.isIntegrallyClosed_dvd_iff
File: Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean

tactic: simpa only [RingHom.mem_ker, RingHom.coe_comp, coe_evalRingHom, coe_mapRingHom,
  Function.comp_apply, eval_map, ← aeval_def] using
  aeval_eq_zero_of_dvd_aeval_eq_zero hp (minpoly.aeval R s)
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
s : S
hs : IsIntegral R s
p : R[X]
hp : minpoly R s ∣ p
⊢ (Polynomial.aeval s) p = 0
state_after: no goals
Theorem: Batteries.UnionFind.equiv_push
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [Equiv]
state_before: a b : Nat
self : UnionFind
⊢ self.push.Equiv a b ↔ self.Equiv a b
state_after: no goals