1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: one_memℓp_infty
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rintro i ⟨i, rfl⟩
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
⊢ 1 ∈ upperBounds (Set.range fun i => ‖1 i‖)
state_after: case intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
i : I
⊢ (fun i => ‖1 i‖) i ≤ 1

tactic: exact norm_one.le
state_before: case intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝² : (i : α) → NormedAddCommGroup (E i)
I : Type u_3
B : I → Type u_4
inst✝¹ : (i : I) → NormedRing (B i)
inst✝ : ∀ (i : I), NormOneClass (B i)
i : I
⊢ (fun i => ‖1 i‖) i ≤ 1
state_after: no goals
Theorem: PowerSeries.coeff_one_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_X, if_pos rfl]
state_before: R : Type u_1
inst✝ : Semiring R
⊢ (coeff R 1) X = 1
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.associator_naturality_middle
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ (X ◁ f) ▷ Z ≫ (α_ X Y' Z).hom = (α_ X Y Z).hom ≫ X ◁ f ▷ Z
state_after: no goals
Theorem: LinearPMap.IsClosable.existsUnique
File: Mathlib/Topology/Algebra/Module/LinearPMap.lean

tactic: refine exists_unique_of_exists_of_unique hf fun _ _ hy₁ hy₂ => eq_of_eq_graph ?_
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
⊢ ∃! f', f.graph.topologicalClosure = f'.graph
state_after: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
x✝¹ x✝ : E →ₗ.[R] F
hy₁ : f.graph.topologicalClosure = x✝¹.graph
hy₂ : f.graph.topologicalClosure = x✝.graph
⊢ x✝¹.graph = x✝.graph

tactic: rw [← hy₁, ← hy₂]
state_before: R : Type u_1
E : Type u_2
F : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : AddCommGroup E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module R E
inst✝⁷ : Module R F
inst✝⁶ : TopologicalSpace E
inst✝⁵ : TopologicalSpace F
inst✝⁴ : ContinuousAdd E
inst✝³ : ContinuousAdd F
inst✝² : TopologicalSpace R
inst✝¹ : ContinuousSMul R E
inst✝ : ContinuousSMul R F
f : E →ₗ.[R] F
hf : f.IsClosable
x✝¹ x✝ : E →ₗ.[R] F
hy₁ : f.graph.topologicalClosure = x✝¹.graph
hy₂ : f.graph.topologicalClosure = x✝.graph
⊢ x✝¹.graph = x✝.graph
state_after: no goals
Theorem: List.dedup_append
File: Mathlib/Data/List/Dedup.lean

tactic: induction' l₁ with a l₁ IH
state_before: α : Type u
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
state_after: case nil
α : Type u
inst✝ : DecidableEq α
l₂ : List α
⊢ ([] ++ l₂).dedup = [] ∪ l₂.dedup

case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: l₁ ++ l₂).dedup = a :: l₁ ∪ l₂.dedup

tactic: simp only [cons_union] at *
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: l₁ ++ l₂).dedup = a :: l₁ ∪ l₂.dedup
state_after: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: l₁ ++ l₂).dedup = List.insert a (l₁ ∪ l₂.dedup)

tactic: rw [← IH, cons_append]
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: l₁ ++ l₂).dedup = List.insert a (l₁ ∪ l₂.dedup)
state_after: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup

tactic: by_cases h : a ∈ dedup (l₁ ++ l₂)
state_before: case cons
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup
state_after: case pos
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
h : a ∈ (l₁ ++ l₂).dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup

case neg
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
h : a ∉ (l₁ ++ l₂).dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup

tactic: rfl
state_before: case nil
α : Type u
inst✝ : DecidableEq α
l₂ : List α
⊢ ([] ++ l₂).dedup = [] ∪ l₂.dedup
state_after: no goals

tactic: rw [dedup_cons_of_mem' h, insert_of_mem h]
state_before: case pos
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
h : a ∈ (l₁ ++ l₂).dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup
state_after: no goals

tactic: rw [dedup_cons_of_not_mem' h, insert_of_not_mem h]
state_before: case neg
α : Type u
inst✝ : DecidableEq α
l₂ : List α
a : α
l₁ : List α
IH : (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
h : a ∉ (l₁ ++ l₂).dedup
⊢ (a :: (l₁ ++ l₂)).dedup = List.insert a (l₁ ++ l₂).dedup
state_after: no goals
Theorem: Dense.borel_eq_generateFrom_Ioc_mem
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean

tactic: simp
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α✝
inst✝¹¹ : TopologicalSpace α✝
inst✝¹⁰ : MeasurableSpace α✝
inst✝⁹ : OpensMeasurableSpace α✝
inst✝⁸ : MeasurableSpace δ
inst✝⁷ : LinearOrder α✝
inst✝⁶ : OrderClosedTopology α✝
a b x : α✝
α : Type u_5
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : SecondCountableTopology α
inst✝¹ : DenselyOrdered α
inst✝ : NoMaxOrder α
s : Set α
hd : Dense s
⊢ ∀ (x : α), IsTop x → x ∈ s
state_after: no goals
Theorem: Ideal.absNorm_dvd_norm_of_mem
File: Mathlib/RingTheory/Ideal/Norm.lean

tactic: rw [← Int.dvd_natAbs, ← absNorm_span_singleton x, Int.natCast_dvd_natCast]
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
I : Ideal S
x : S
h : x ∈ I
⊢ ↑(absNorm I) ∣ (Algebra.norm ℤ) x
state_after: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
I : Ideal S
x : S
h : x ∈ I
⊢ absNorm I ∣ absNorm (span {x})

tactic: exact absNorm_dvd_absNorm_of_le ((span_singleton_le_iff_mem _).mpr h)
state_before: S : Type u_1
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain S
inst✝³ : Nontrivial S
inst✝² : IsDedekindDomain S
inst✝¹ : Module.Free ℤ S
inst✝ : Module.Finite ℤ S
I : Ideal S
x : S
h : x ∈ I
⊢ absNorm I ∣ absNorm (span {x})
state_after: no goals
Theorem: QuadraticForm.toMatrix'_comp
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: ext
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
n : Type w
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : DecidableEq n
inst✝² : Invertible 2
m : Type w
inst✝¹ : DecidableEq m
inst✝ : Fintype m
Q : QuadraticForm R (m → R)
f : (n → R) →ₗ[R] m → R
⊢ (Q.comp f).toMatrix' = (LinearMap.toMatrix' f)ᵀ * Q.toMatrix' * LinearMap.toMatrix' f
state_after: case a
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
n : Type w
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : DecidableEq n
inst✝² : Invertible 2
m : Type w
inst✝¹ : DecidableEq m
inst✝ : Fintype m
Q : QuadraticForm R (m → R)
f : (n → R) →ₗ[R] m → R
i✝ j✝ : n
⊢ (Q.comp f).toMatrix' i✝ j✝ = ((LinearMap.toMatrix' f)ᵀ * Q.toMatrix' * LinearMap.toMatrix' f) i✝ j✝

tactic: simp only [QuadraticForm.associated_comp, LinearMap.toMatrix₂'_compl₁₂, toMatrix']
state_before: case a
S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
n : Type w
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : DecidableEq n
inst✝² : Invertible 2
m : Type w
inst✝¹ : DecidableEq m
inst✝ : Fintype m
Q : QuadraticForm R (m → R)
f : (n → R) →ₗ[R] m → R
i✝ j✝ : n
⊢ (Q.comp f).toMatrix' i✝ j✝ = ((LinearMap.toMatrix' f)ᵀ * Q.toMatrix' * LinearMap.toMatrix' f) i✝ j✝
state_after: no goals
Theorem: Matrix.inv_adjugate
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: refine inv_eq_left_inv ?_
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
h : IsUnit A.det
⊢ A.adjugate⁻¹ = h.unit⁻¹ • A
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
h : IsUnit A.det
⊢ h.unit⁻¹ • A * A.adjugate = 1

tactic: rw [smul_mul, mul_adjugate, Units.smul_def, smul_smul, h.val_inv_mul, one_smul]
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
h : IsUnit A.det
⊢ h.unit⁻¹ • A * A.adjugate = 1
state_after: no goals
Theorem: finprod_induction
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod]
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
⊢ p (∏ᶠ (i : α), f i)
state_after: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
⊢ p (if h : (mulSupport ((fun i => f i) ∘ PLift.down)).Finite then ∏ i ∈ h.toFinset, f i.down else 1)

tactic: split_ifs
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
⊢ p (if h : (mulSupport ((fun i => f i) ∘ PLift.down)).Finite then ∏ i ∈ h.toFinset, f i.down else 1)
state_after: case pos
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : (mulSupport ((fun i => f i) ∘ PLift.down)).Finite
⊢ p (∏ i ∈ h✝.toFinset, f i.down)

case neg
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : ¬(mulSupport ((fun i => f i) ∘ PLift.down)).Finite
⊢ p 1

tactic: exacts [Finset.prod_induction _ _ hp₁ hp₀ fun i _ => hp₂ _, hp₀]
state_before: case pos
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : (mulSupport ((fun i => f i) ∘ PLift.down)).Finite
⊢ p (∏ i ∈ h✝.toFinset, f i.down)

case neg
G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
p : M → Prop
hp₀ : p 1
hp₁ : ∀ (x y : M), p x → p y → p (x * y)
hp₂ : ∀ (i : α), p (f i)
h✝ : ¬(mulSupport ((fun i => f i) ∘ PLift.down)).Finite
⊢ p 1
state_after: no goals
Theorem: CircleDeg1Lift.transnumAuxSeq_zero
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [transnumAuxSeq]
state_before: f g : CircleDeg1Lift
⊢ f.transnumAuxSeq 0 = f 0
state_after: no goals
Theorem: Int.toNat_add_toNat_neg_eq_norm
File: Mathlib/Analysis/NormedSpace/Int.lean

tactic: simpa only [NNReal.coe_natCast, NNReal.coe_add] using
  congrArg NNReal.toReal (toNat_add_toNat_neg_eq_nnnorm n)
state_before: n : ℤ
⊢ ↑n.toNat + ↑(-n).toNat = ‖n‖
state_after: no goals
Theorem: Nat.decreasingInduction_succ_left
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Subsingleton.elim mn (Nat.le_trans (le_succ m) smn), decreasingInduction_trans,
  decreasingInduction_succ']
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
smn : m + 1 ≤ n
mn : m ≤ n
hP : P n
⊢ decreasingInduction h mn hP = h m (decreasingInduction h smn hP)
state_after: case msm
a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
smn : m + 1 ≤ n
mn : m ≤ n
hP : P n
⊢ m ≤ m + 1

tactic: apply Nat.le_succ
state_before: case msm
a b c d m n k : ℕ
p q : ℕ → Prop
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
smn : m + 1 ≤ n
mn : m ≤ n
hP : P n
⊢ m ≤ m + 1
state_after: no goals
Theorem: Finsupp.neLocus_self_sub_left
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: rw [neLocus_comm, neLocus_self_sub_right]
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ (f - g).neLocus f = g.support
state_after: no goals
Theorem: Finsupp.sum_mul
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp only [Finsupp.sum, Finset.sum_mul]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : NonUnitalNonAssocSemiring R
inst✝ : NonUnitalNonAssocSemiring S
b : S
s : α →₀ R
f : α → R → S
⊢ s.sum f * b = s.sum fun a c => f a c * b
state_after: no goals
Theorem: ZFSet.IsTransitive.union
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rw [← sUnion_pair]
state_before: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
⊢ (x ∪ y).IsTransitive
state_after: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
⊢ (⋃₀ {x, y}).IsTransitive

tactic: apply IsTransitive.sUnion' fun z => _
state_before: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
⊢ (⋃₀ {x, y}).IsTransitive
state_after: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
⊢ ∀ z ∈ {x, y}, z.IsTransitive

tactic: intro
state_before: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
⊢ ∀ z ∈ {x, y}, z.IsTransitive
state_after: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z✝ : ZFSet
⊢ z✝ ∈ {x, y} → z✝.IsTransitive

tactic: rw [mem_pair]
state_before: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z✝ : ZFSet
⊢ z✝ ∈ {x, y} → z✝.IsTransitive
state_after: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z✝ : ZFSet
⊢ z✝ = x ∨ z✝ = y → z✝.IsTransitive

tactic: rintro (rfl | rfl)
state_before: x y z : ZFSet
hx : x.IsTransitive
hy : y.IsTransitive
z✝ : ZFSet
⊢ z✝ = x ∨ z✝ = y → z✝.IsTransitive
state_after: case inl
y z : ZFSet
hy : y.IsTransitive
z✝ : ZFSet
hx : z✝.IsTransitive
⊢ z✝.IsTransitive

case inr
x z : ZFSet
hx : x.IsTransitive
z✝ : ZFSet
hy : z✝.IsTransitive
⊢ z✝.IsTransitive

tactic: assumption'
state_before: case inl
y z : ZFSet
hy : y.IsTransitive
z✝ : ZFSet
hx : z✝.IsTransitive
⊢ z✝.IsTransitive

case inr
x z : ZFSet
hx : x.IsTransitive
z✝ : ZFSet
hy : z✝.IsTransitive
⊢ z✝.IsTransitive
state_after: no goals
Theorem: smul_eq_zero_iff_right
File: Mathlib/Algebra/Module/Defs.lean

tactic: simp [hc]
state_before: α : Type u_1
R : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
inst✝³ : Zero R
inst✝² : Zero M
inst✝¹ : SMulWithZero R M
inst✝ : NoZeroSMulDivisors R M
c : R
x : M
hc : c ≠ 0
⊢ c • x = 0 ↔ x = 0
state_after: no goals
Theorem: Rat.divInt_mul_divInt'
File: Mathlib/Data/Rat/Defs.lean

tactic: obtain rfl | h₁ := eq_or_ne d₁ 0
state_before: q : ℚ
n₁ d₁ n₂ d₂ : ℤ
⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)
state_after: case inl
q : ℚ
n₁ n₂ d₂ : ℤ
⊢ n₁ /. 0 * (n₂ /. d₂) = n₁ * n₂ /. (0 * d₂)

case inr
q : ℚ
n₁ d₁ n₂ d₂ : ℤ
h₁ : d₁ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)

tactic: obtain rfl | h₂ := eq_or_ne d₂ 0
state_before: case inr
q : ℚ
n₁ d₁ n₂ d₂ : ℤ
h₁ : d₁ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)
state_after: case inr.inl
q : ℚ
n₁ d₁ n₂ : ℤ
h₁ : d₁ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. 0) = n₁ * n₂ /. (d₁ * 0)

case inr.inr
q : ℚ
n₁ d₁ n₂ d₂ : ℤ
h₁ : d₁ ≠ 0
h₂ : d₂ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)

tactic: exact divInt_mul_divInt _ _ h₁ h₂
state_before: case inr.inr
q : ℚ
n₁ d₁ n₂ d₂ : ℤ
h₁ : d₁ ≠ 0
h₂ : d₂ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)
state_after: no goals

tactic: simp
state_before: case inl
q : ℚ
n₁ n₂ d₂ : ℤ
⊢ n₁ /. 0 * (n₂ /. d₂) = n₁ * n₂ /. (0 * d₂)
state_after: no goals

tactic: simp
state_before: case inr.inl
q : ℚ
n₁ d₁ n₂ : ℤ
h₁ : d₁ ≠ 0
⊢ n₁ /. d₁ * (n₂ /. 0) = n₁ * n₂ /. (d₁ * 0)
state_after: no goals
Theorem: Nat.prod_pow_factorization_centralBinom
File: Mathlib/Data/Nat/Choose/Factorization.lean

tactic: apply prod_pow_factorization_choose
state_before: p n✝ k n : ℕ
⊢ ∏ p ∈ Finset.range (2 * n + 1), p ^ n.centralBinom.factorization p = n.centralBinom
state_after: case hkn
p n✝ k n : ℕ
⊢ n ≤ 2 * n

tactic: omega
state_before: case hkn
p n✝ k n : ℕ
⊢ n ≤ 2 * n
state_after: no goals
Theorem: nhdsWithin_subtype_eq_bot_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [inf_principal_eq_bot_iff_comap, nhdsWithin, nhdsWithin, comap_inf, comap_principal,
  nhds_induced]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝ : TopologicalSpace X
s t : Set X
x : ↑s
⊢ 𝓝[Subtype.val ⁻¹' t] x = ⊥ ↔ 𝓝[t] ↑x ⊓ 𝓟 s = ⊥
state_after: no goals
Theorem: IsUnifLocDoublingMeasure.ae_tendsto_measure_inter_div
File: Mathlib/MeasureTheory/Covering/DensityTheorem.lean

tactic: filter_upwards [(vitaliFamily μ K).ae_tendsto_measure_inter_div S] with x hx ι l w δ δlim
  xmem using hx.comp (tendsto_closedBall_filterAt μ _ _ δlim xmem)
state_before: α : Type u_1
inst✝⁶ : MetricSpace α
inst✝⁵ : MeasurableSpace α
μ : Measure α
inst✝⁴ : IsUnifLocDoublingMeasure μ
inst✝³ : SecondCountableTopology α
inst✝² : BorelSpace α
inst✝¹ : IsLocallyFiniteMeasure μ
E : Type u_2
inst✝ : NormedAddCommGroup E
S : Set α
K : ℝ
⊢ ∀ᵐ (x : α) ∂μ.restrict S,
    ∀ {ι : Type u_3} {l : Filter ι} (w : ι → α) (δ : ι → ℝ),
      Tendsto δ l (𝓝[>] 0) →
        (∀ᶠ (j : ι) in l, x ∈ closedBall (w j) (K * δ j)) →
          Tendsto (fun j => μ (S ∩ closedBall (w j) (δ j)) / μ (closedBall (w j) (δ j))) l (𝓝 1)
state_after: no goals
Theorem: Set.ncard_subtype
File: Mathlib/Data/Set/Card.lean

tactic: convert (ncard_image_of_injective _ (@Subtype.coe_injective _ P)).symm
state_before: α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
P : α → Prop
s : Set α
⊢ {x | ↑x ∈ s}.ncard = (s ∩ setOf P).ncard
state_after: case h.e'_3.h.e'_2
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
P : α → Prop
s : Set α
⊢ s ∩ setOf P = (fun a => ↑a) '' {x | ↑x ∈ s}

tactic: ext x
state_before: case h.e'_3.h.e'_2
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
P : α → Prop
s : Set α
⊢ s ∩ setOf P = (fun a => ↑a) '' {x | ↑x ∈ s}
state_after: case h.e'_3.h.e'_2.h
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
P : α → Prop
s : Set α
x : α
⊢ x ∈ s ∩ setOf P ↔ x ∈ (fun a => ↑a) '' {x | ↑x ∈ s}

tactic: simp [← and_assoc, exists_eq_right]
state_before: case h.e'_3.h.e'_2.h
α : Type u_1
β : Type u_2
s✝ t : Set α
f : α → β
P : α → Prop
s : Set α
x : α
⊢ x ∈ s ∩ setOf P ↔ x ∈ (fun a => ↑a) '' {x | ↑x ∈ s}
state_after: no goals
Theorem: Subgroup.le_prod_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: simpa only [← Subgroup.toSubmonoid_le] using Submonoid.le_prod_iff
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup G
K : Subgroup N
J : Subgroup (G × N)
⊢ J ≤ H.prod K ↔ map (MonoidHom.fst G N) J ≤ H ∧ map (MonoidHom.snd G N) J ≤ K
state_after: no goals
Theorem: IsSelfAdjoint.isSymmetric
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: intro x y
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : IsSelfAdjoint A
⊢ (↑A).IsSymmetric
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : IsSelfAdjoint A
x y : E
⊢ ⟪↑A x, y⟫_𝕜 = ⟪x, ↑A y⟫_𝕜

tactic: rw_mod_cast [← A.adjoint_inner_right, hA.adjoint_eq]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁸ : RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : InnerProductSpace 𝕜 F
inst✝² : InnerProductSpace 𝕜 G
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
A : E →L[𝕜] E
hA : IsSelfAdjoint A
x y : E
⊢ ⟪↑A x, y⟫_𝕜 = ⟪x, ↑A y⟫_𝕜
state_after: no goals
Theorem: Complex.norm_log_one_sub_inv_sub_self_le
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: convert norm_log_one_sub_inv_add_logTaylor_neg_le 1 hz using 2
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ ‖log (1 - z)⁻¹ - z‖ ≤ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2
state_after: case h.e'_3.h.e'_3
z : ℂ
hz : ‖z‖ < 1
⊢ log (1 - z)⁻¹ - z = log (1 - z)⁻¹ + logTaylor (1 + 1) (-z)

case h.e'_4.h.e'_6
z : ℂ
hz : ‖z‖ < 1
⊢ 2 = ↑1 + 1

tactic: simp [logTaylor_succ, logTaylor_zero, sub_eq_add_neg]
state_before: case h.e'_3.h.e'_3
z : ℂ
hz : ‖z‖ < 1
⊢ log (1 - z)⁻¹ - z = log (1 - z)⁻¹ + logTaylor (1 + 1) (-z)
state_after: no goals

tactic: norm_num
state_before: case h.e'_4.h.e'_6
z : ℂ
hz : ‖z‖ < 1
⊢ 2 = ↑1 + 1
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_apply_univ
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [restrict_apply MeasurableSet.univ, Set.univ_inter]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
⊢ (μ.restrict s) univ = μ s
state_after: no goals