1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MvPolynomial.mem_support_not_mem_vars_zero
File: Mathlib/Algebra/MvPolynomial/Variables.lean

tactic: contrapose! h
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 f : MvPolynomial σ R
x : σ →₀ ℕ
H : x ∈ f.support
v : σ
h : v ∉ f.vars
⊢ x v = 0
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q f : MvPolynomial σ R
x : σ →₀ ℕ
H : x ∈ f.support
v : σ
h : x v ≠ 0
⊢ v ∈ f.vars

tactic: exact (mem_vars v).mpr ⟨x, H, Finsupp.mem_support_iff.mpr h⟩
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 f : MvPolynomial σ R
x : σ →₀ ℕ
H : x ∈ f.support
v : σ
h : x v ≠ 0
⊢ v ∈ f.vars
state_after: no goals
Theorem: tendsto_indicator_const_iff_tendsto_pi_pure'
File: Mathlib/Topology/IndicatorConstPointwise.lean

tactic: rw [tendsto_indicator_const_iff_forall_eventually' _ b nhd_b nhd_o, tendsto_pi]
state_before: α : Type u_1
A : Set α
β : Type u_2
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
ι : Type u_3
L : Filter ι
As : ι → Set α
b : β
nhd_b : {0}ᶜ ∈ 𝓝 b
nhd_o : {b}ᶜ ∈ 𝓝 0
⊢ Tendsto (fun i => (As i).indicator fun x => b) L (𝓝 (A.indicator fun x => b)) ↔
    Tendsto As L (pi fun x => pure (x ∈ A))
state_after: α : Type u_1
A : Set α
β : Type u_2
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
ι : Type u_3
L : Filter ι
As : ι → Set α
b : β
nhd_b : {0}ᶜ ∈ 𝓝 b
nhd_o : {b}ᶜ ∈ 𝓝 0
⊢ (∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A) ↔ ∀ (i : α), Tendsto (fun x => As x i) L (pure (i ∈ A))

tactic: simp_rw [tendsto_pure]
state_before: α : Type u_1
A : Set α
β : Type u_2
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
ι : Type u_3
L : Filter ι
As : ι → Set α
b : β
nhd_b : {0}ᶜ ∈ 𝓝 b
nhd_o : {b}ᶜ ∈ 𝓝 0
⊢ (∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A) ↔ ∀ (i : α), Tendsto (fun x => As x i) L (pure (i ∈ A))
state_after: α : Type u_1
A : Set α
β : Type u_2
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
ι : Type u_3
L : Filter ι
As : ι → Set α
b : β
nhd_b : {0}ᶜ ∈ 𝓝 b
nhd_o : {b}ᶜ ∈ 𝓝 0
⊢ (∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A) ↔ ∀ (i : α), ∀ᶠ (x : ι) in L, As x i = (i ∈ A)

tactic: aesop
state_before: α : Type u_1
A : Set α
β : Type u_2
inst✝¹ : Zero β
inst✝ : TopologicalSpace β
ι : Type u_3
L : Filter ι
As : ι → Set α
b : β
nhd_b : {0}ᶜ ∈ 𝓝 b
nhd_o : {b}ᶜ ∈ 𝓝 0
⊢ (∀ (x : α), ∀ᶠ (i : ι) in L, x ∈ As i ↔ x ∈ A) ↔ ∀ (i : α), ∀ᶠ (x : ι) in L, As x i = (i ∈ A)
state_after: no goals
Theorem: CategoryTheory.MonoidalOfChosenFiniteProducts.tensor_id
File: Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean

tactic: apply IsLimit.hom_ext (ℬ _ _).isLimit
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
⊢ tensorHom ℬ (𝟙 X₁) (𝟙 X₂) = 𝟙 (tensorObj ℬ X₁ X₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
⊢ ∀ (j : Discrete WalkingPair),
    tensorHom ℬ (𝟙 X₁) (𝟙 X₂) ≫ (ℬ X₁ X₂).cone.π.app j = 𝟙 (tensorObj ℬ X₁ X₂) ≫ (ℬ X₁ X₂).cone.π.app j

tactic: dsimp [tensorHom]
state_before: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
⊢ tensorHom ℬ (𝟙 X₁) (𝟙 X₂) ≫ (ℬ X₁ X₂).cone.π.app { as := WalkingPair.right } =
    𝟙 (tensorObj ℬ X₁ X₂) ≫ (ℬ X₁ X₂).cone.π.app { as := WalkingPair.right }
state_after: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
⊢ (ℬ X₁ X₂).isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ 𝟙 X₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ 𝟙 X₂)) ≫
      BinaryFan.snd (ℬ X₁ X₂).cone =
    𝟙 (tensorObj ℬ X₁ X₂) ≫ BinaryFan.snd (ℬ X₁ X₂).cone

tactic: simp
state_before: case mk.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
𝒯 : LimitCone (Functor.empty C)
ℬ : (X Y : C) → LimitCone (pair X Y)
X₁ X₂ : C
⊢ (ℬ X₁ X₂).isLimit.lift (BinaryFan.mk (BinaryFan.fst (ℬ X₁ X₂).cone ≫ 𝟙 X₁) (BinaryFan.snd (ℬ X₁ X₂).cone ≫ 𝟙 X₂)) ≫
      BinaryFan.snd (ℬ X₁ X₂).cone =
    𝟙 (tensorObj ℬ X₁ X₂) ≫ BinaryFan.snd (ℬ X₁ X₂).cone
state_after: no goals
Theorem: Seminorm.closedBall_eq_biInter_ball
File: Mathlib/Analysis/Seminorm.lean

tactic: ext y
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x✝ y : E
r✝ : ℝ
x : E
r : ℝ
⊢ p.closedBall x r = ⋂ ρ, ⋂ (_ : ρ > r), p.ball x ρ
state_after: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x✝ y✝ : E
r✝ : ℝ
x : E
r : ℝ
y : E
⊢ y ∈ p.closedBall x r ↔ y ∈ ⋂ ρ, ⋂ (_ : ρ > r), p.ball x ρ

tactic: simp_rw [mem_closedBall, mem_iInter₂, mem_ball, ← forall_lt_iff_le']
state_before: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝² : SeminormedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : SMul 𝕜 E
p : Seminorm 𝕜 E
x✝ y✝ : E
r✝ : ℝ
x : E
r : ℝ
y : E
⊢ y ∈ p.closedBall x r ↔ y ∈ ⋂ ρ, ⋂ (_ : ρ > r), p.ball x ρ
state_after: no goals
Theorem: PMF.support_bernoulli
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: refine Set.ext fun b => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ (bernoulli p h).support = {b | bif b then p ≠ 0 else p ≠ 1}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b✝ b : Bool
⊢ b ∈ (bernoulli p h).support ↔ b ∈ {b | bif b then p ≠ 0 else p ≠ 1}

tactic: induction b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b✝ b : Bool
⊢ b ∈ (bernoulli p h).support ↔ b ∈ {b | bif b then p ≠ 0 else p ≠ 1}
state_after: case false
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ false ∈ (bernoulli p h).support ↔ false ∈ {b | bif b then p ≠ 0 else p ≠ 1}

case true
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ true ∈ (bernoulli p h).support ↔ true ∈ {b | bif b then p ≠ 0 else p ≠ 1}

tactic: simp_rw [mem_support_iff, bernoulli_apply, Bool.cond_false, Ne, tsub_eq_zero_iff_le, not_le]
state_before: case false
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ false ∈ (bernoulli p h).support ↔ false ∈ {b | bif b then p ≠ 0 else p ≠ 1}
state_after: case false
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ p < 1 ↔ false ∈ {b | bif b then ¬p = 0 else ¬p = 1}

tactic: exact ⟨ne_of_lt, lt_of_le_of_ne h⟩
state_before: case false
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ p < 1 ↔ false ∈ {b | bif b then ¬p = 0 else ¬p = 1}
state_after: no goals

tactic: simp only [mem_support_iff, bernoulli_apply, Bool.cond_true, Set.mem_setOf_eq]
state_before: case true
α : Type u_1
β : Type u_2
γ : Type u_3
p : ℝ≥0∞
h : p ≤ 1
b : Bool
⊢ true ∈ (bernoulli p h).support ↔ true ∈ {b | bif b then p ≠ 0 else p ≠ 1}
state_after: no goals
Theorem: CategoryTheory.Bicategory.id_whiskerLeft_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g : a ⟶ b
η : f ⟶ g
⊢ η = (λ_ f).inv ≫ 𝟙 a ◁ η ≫ (λ_ g).hom
state_after: no goals
Theorem: Algebra.rank_le_of_surjective_injective
File: Mathlib/LinearAlgebra/Dimension/Basic.lean

tactic: simpa only [lift_id] using lift_rank_le_of_surjective_injective i j hi hj hc
state_before: R✝ : Type u
R'✝ : Type u'
M M₁ : Type v
M' : Type v'
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₁
inst✝¹⁰ : Module R'✝ M'
inst✝⁹ : Module R'✝ M₁
R : Type w
S : Type v
inst✝⁸ : CommRing R
inst✝⁷ : Ring S
inst✝⁶ : Algebra R S
R' : Type w'
S'✝ : Type v'
inst✝⁵ : CommRing R'
inst✝⁴ : Ring S'✝
inst✝³ : Algebra R' S'✝
S' : Type v
inst✝² : CommRing R'
inst✝¹ : Ring S'
inst✝ : Algebra R' S'
i : R →+* R'
j : S →+* S'
hi : Surjective ⇑i
hj : Injective ⇑j
hc : (algebraMap R' S').comp i = j.comp (algebraMap R S)
⊢ Module.rank R S ≤ Module.rank R' S'
state_after: no goals
Theorem: ChainComplex.toSingle₀Equiv_symm_apply_f_zero
File: Mathlib/Algebra/Homology/Single.lean

tactic: simp [toSingle₀Equiv]
state_before: V : Type u
inst✝² : Category.{v, u} V
inst✝¹ : HasZeroMorphisms V
inst✝ : HasZeroObject V
C : ChainComplex V ℕ
X : V
f : C.X 0 ⟶ X
hf : C.d 1 0 ≫ f = 0
⊢ ((C.toSingle₀Equiv X).symm ⟨f, hf⟩).f 0 = f
state_after: no goals
Theorem: Int.bitwise_or
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise or = lor
state_after: case h.h
m n : ℤ
⊢ bitwise or m n = m.lor n

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
    negSucc.injEq, Bool.true_or, Nat.land]
state_before: case h.h
m n : ℤ
⊢ bitwise or m n = m.lor n
state_after: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(x || !y)) m n = Nat.bitwise (fun a b => a && !b) n m

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || y)) m n = Nat.bitwise (fun a b => a && !b) m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || !y)) m n = m &&& n

tactic: rfl
state_before: case h.h.ofNat.ofNat
m n : ℕ
⊢ bitwise or (ofNat m) (ofNat n) = (ofNat m).lor (ofNat n)
state_after: no goals

tactic: rw [Nat.bitwise_swap, Function.swap]
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(x || !y)) m n = Nat.bitwise (fun a b => a && !b) n m
state_after: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun y x => !(x || !y)) n m = Nat.bitwise (fun a b => a && !b) n m

tactic: congr
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun y x => !(x || !y)) n m = Nat.bitwise (fun a b => a && !b) n m
state_after: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun y x => !(x || !y)) = fun a b => a && !b

tactic: funext x y
state_before: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun y x => !(x || !y)) = fun a b => a && !b
state_after: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(y || !x)) = (x && !y)

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(y || !x)) = (x && !y)
state_after: no goals

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || y)) m n = Nat.bitwise (fun a b => a && !b) m n
state_after: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !(!x || y)) = fun a b => a && !b

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !(!x || y)) = fun a b => a && !b
state_after: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || y)) = (x && !y)

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || y)) = (x && !y)
state_after: no goals

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || !y)) m n = m &&& n
state_after: case h.h.negSucc.negSucc.e_f
m n : ℕ
⊢ (fun x y => !(!x || !y)) = and

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_f
m n : ℕ
⊢ (fun x y => !(!x || !y)) = and
state_after: case h.h.negSucc.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || !y)) = (x && y)

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || !y)) = (x && y)
state_after: no goals
Theorem: Complex.sin_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [ofReal_sin]
state_before: ⊢ sin (↑π / 2) = ↑(Real.sin (π / 2))
state_after: ⊢ sin (↑π / 2) = sin ↑(π / 2)

tactic: simp
state_before: ⊢ sin (↑π / 2) = sin ↑(π / 2)
state_after: no goals

tactic: simp
state_before: ⊢ ↑(Real.sin (π / 2)) = 1
state_after: no goals
Theorem: MeasureTheory.StronglyMeasurable.mul_iff_right
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simp only [mul_inv_cancel_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
f g : α → β
mα : MeasurableSpace α
inst✝² : TopologicalSpace β
inst✝¹ : CommGroup β
inst✝ : TopologicalGroup β
hf : StronglyMeasurable f
h : StronglyMeasurable (f * g)
⊢ g = f * g * f⁻¹
state_after: no goals
Theorem: Complex.arg_nonneg_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rcases eq_or_ne z 0 with (rfl | h₀)
state_before: a x z✝ z : ℂ
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im
state_after: case inl
a x z : ℂ
⊢ 0 ≤ arg 0 ↔ 0 ≤ im 0

case inr
a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im

tactic: calc
  0 ≤ arg z ↔ 0 ≤ Real.sin (arg z) :=
    ⟨fun h => Real.sin_nonneg_of_mem_Icc ⟨h, arg_le_pi z⟩, by
      contrapose!
      intro h
      exact Real.sin_neg_of_neg_of_neg_pi_lt h (neg_pi_lt_arg _)⟩
  _ ↔ _ := by rw [sin_arg, le_div_iff (abs.pos h₀), zero_mul]
state_before: case inr
a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ z.arg ↔ 0 ≤ z.im
state_after: no goals

tactic: simp
state_before: case inl
a x z : ℂ
⊢ 0 ≤ arg 0 ↔ 0 ≤ im 0
state_after: no goals

tactic: contrapose!
state_before: a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ Real.sin z.arg → 0 ≤ z.arg
state_after: a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ z.arg < 0 → Real.sin z.arg < 0

tactic: intro h
state_before: a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ z.arg < 0 → Real.sin z.arg < 0
state_after: a x z✝ z : ℂ
h₀ : z ≠ 0
h : z.arg < 0
⊢ Real.sin z.arg < 0

tactic: exact Real.sin_neg_of_neg_of_neg_pi_lt h (neg_pi_lt_arg _)
state_before: a x z✝ z : ℂ
h₀ : z ≠ 0
h : z.arg < 0
⊢ Real.sin z.arg < 0
state_after: no goals

tactic: rw [sin_arg, le_div_iff (abs.pos h₀), zero_mul]
state_before: a x z✝ z : ℂ
h₀ : z ≠ 0
⊢ 0 ≤ Real.sin z.arg ↔ 0 ≤ z.im
state_after: no goals
Theorem: Dioph.abs_poly_dioph
File: Mathlib/NumberTheory/Dioph.lean

tactic: dsimp
state_before: α β γ : Type u
S S' : Set (α → ℕ)
p : Poly α
v : Option α → ℕ
⊢ {v | (fun v => (p v).natAbs) (v ∘ some) = v none} v ↔
    ((Poly.map some p - Poly.proj none) * (Poly.map some p + Poly.proj none)) v = 0
state_after: α β γ : Type u
S S' : Set (α → ℕ)
p : Poly α
v : Option α → ℕ
⊢ {v | (p (v ∘ some)).natAbs = v none} v ↔ (p (v ∘ some) - ↑(v none)) * (p (v ∘ some) + ↑(v none)) = 0

tactic: exact Int.eq_natAbs_iff_mul_eq_zero
state_before: α β γ : Type u
S S' : Set (α → ℕ)
p : Poly α
v : Option α → ℕ
⊢ {v | (p (v ∘ some)).natAbs = v none} v ↔ (p (v ∘ some) - ↑(v none)) * (p (v ∘ some) + ↑(v none)) = 0
state_after: no goals
Theorem: MeasurableEmbedding.iff_comap_eq
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

tactic: exact comap_measurable f
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → α
hf : Injective f ∧ MeasurableSpace.comap f inst✝¹ = inst✝² ∧ MeasurableSet (range f)
⊢ Measurable f
state_after: no goals

tactic: rintro _ ⟨s, hs, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → α
hf : Injective f ∧ MeasurableSpace.comap f inst✝¹ = inst✝² ∧ MeasurableSet (range f)
⊢ ∀ ⦃s : Set α⦄, MeasurableSet s → MeasurableSet (f '' s)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → α
hf : Injective f ∧ MeasurableSpace.comap f inst✝¹ = inst✝² ∧ MeasurableSet (range f)
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (f '' (f ⁻¹' s))

tactic: simpa only [image_preimage_eq_inter_range] using hs.inter hf.2.2
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → α
hf : Injective f ∧ MeasurableSpace.comap f inst✝¹ = inst✝² ∧ MeasurableSet (range f)
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet (f '' (f ⁻¹' s))
state_after: no goals
Theorem: CategoryTheory.NatTrans.leftDerived_id
File: Mathlib/CategoryTheory/Abelian/LeftDerived.lean

tactic: dsimp only [leftDerived]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasProjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ leftDerived (𝟙 F) n = 𝟙 (F.leftDerived n)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasProjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ whiskerRight (leftDerivedToHomotopyCategory (𝟙 F)) (HomotopyCategory.homologyFunctor D (ComplexShape.down ℕ) n) =
    𝟙 (F.leftDerived n)

tactic: simp only [leftDerivedToHomotopyCategory_id, whiskerRight_id']
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasProjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ whiskerRight (leftDerivedToHomotopyCategory (𝟙 F)) (HomotopyCategory.homologyFunctor D (ComplexShape.down ℕ) n) =
    𝟙 (F.leftDerived n)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasProjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ 𝟙 (F.leftDerivedToHomotopyCategory ⋙ HomotopyCategory.homologyFunctor D (ComplexShape.down ℕ) n) = 𝟙 (F.leftDerived n)

tactic: rfl
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u_1
inst✝⁴ : Category.{u_2, u_1} D
inst✝³ : Abelian C
inst✝² : HasProjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : F.Additive
n : ℕ
⊢ 𝟙 (F.leftDerivedToHomotopyCategory ⋙ HomotopyCategory.homologyFunctor D (ComplexShape.down ℕ) n) = 𝟙 (F.leftDerived n)
state_after: no goals
Theorem: ContinuousMonoidHom.toContinuousMap_injective
File: Mathlib/Topology/Algebra/ContinuousMonoidHom.lean

tactic: convert DFunLike.ext_iff.1 h
state_before: F : Type u_1
A : Type u_2
B : Type u_3
C : Type u_4
D : Type u_5
E : Type u_6
inst✝¹⁰ : Monoid A
inst✝⁹ : Monoid B
inst✝⁸ : Monoid C
inst✝⁷ : Monoid D
inst✝⁶ : CommGroup E
inst✝⁵ : TopologicalSpace A
inst✝⁴ : TopologicalSpace B
inst✝³ : TopologicalSpace C
inst✝² : TopologicalSpace D
inst✝¹ : TopologicalSpace E
inst✝ : TopologicalGroup E
f g : ContinuousMonoidHom A B
h : f.toContinuousMap = g.toContinuousMap
⊢ ∀ (x : A), f x = g x
state_after: no goals
Theorem: Finset.not_mem_compl
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [mem_compl, not_not]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a : α
⊢ a ∉ sᶜ ↔ a ∈ s
state_after: no goals
Theorem: Monovary.sum_smul_comp_perm_eq_sum_smul_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.monovaryOn _).sum_smul_comp_perm_eq_sum_smul_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Monovary f g
⊢ ∑ i : ι, f i • g (σ i) = ∑ i : ι, f i • g i ↔ Monovary f (g ∘ ⇑σ)
state_after: no goals
Theorem: CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
state_before: f g f₁ f₂ : CircleDeg1Lift
h₁ : IsUnit f₁
h₂ : IsUnit f₂
h : τ f₁ = τ f₂
⊢ ∃ F, Semiconj ⇑F ⇑f₁ ⇑f₂
state_after: case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ⇑F ⇑↑f₁ ⇑↑f₂

tactic: exact units_semiconj_of_translationNumber_eq h
state_before: case intro.intro
f g : CircleDeg1Lift
f₁ f₂ : CircleDeg1Liftˣ
h : τ ↑f₁ = τ ↑f₂
⊢ ∃ F, Semiconj ⇑F ⇑↑f₁ ⇑↑f₂
state_after: no goals
Theorem: AnalyticAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean

tactic: have e : (fun z ↦ f z ^ g z) =ᶠ[𝓝 x] fun z ↦ exp (log (f z) * g z) := by
  filter_upwards [(fa.continuousAt.eventually_ne (slitPlane_ne_zero m))]
  intro z fz
  simp only [fz, cpow_def, if_false]
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x
state_after: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x

tactic: rw [analyticAt_congr e]
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => f z ^ g z) x
state_after: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => cexp (log (f z) * g z)) x

tactic: exact ((fa.clog m).mul ga).cexp
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
e : (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
⊢ AnalyticAt ℂ (fun z => cexp (log (f z) * g z)) x
state_after: no goals

tactic: filter_upwards [(fa.continuousAt.eventually_ne (slitPlane_ne_zero m))]
state_before: E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
⊢ (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp (log (f z) * g z)
state_after: case h
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
⊢ ∀ (a : E), f a ≠ 0 → f a ^ g a = cexp (log (f a) * g a)

tactic: intro z fz
state_before: case h
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
⊢ ∀ (a : E), f a ≠ 0 → f a ^ g a = cexp (log (f a) * g a)
state_after: case h
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z✝ : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
z : E
fz : f z ≠ 0
⊢ f z ^ g z = cexp (log (f z) * g z)

tactic: simp only [fz, cpow_def, if_false]
state_before: case h
E : Type
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f g : E → ℂ
z✝ : ℂ
x : E
s : Set E
fa : AnalyticAt ℂ f x
ga : AnalyticAt ℂ g x
m : f x ∈ slitPlane
z : E
fz : f z ≠ 0
⊢ f z ^ g z = cexp (log (f z) * g z)
state_after: no goals
Theorem: Cardinal.lift_two
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp [← one_add_one_eq_two]
state_before: α β : Type u
⊢ lift.{u, v} 2 = 2
state_after: no goals