1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.Tendsto.atTop_mul
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: refine tendsto_atTop_mono' _ ?_ (hf.atTop_mul_const (half_pos hC))
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ (fun x => f x * (C / 2)) ≤ᶠ[l] fun x => f x * g x

tactic: filter_upwards [hg.eventually (lt_mem_nhds (half_lt_self hC)), hf.eventually_ge_atTop 0]
  with x hg hf using mul_le_mul_of_nonneg_left hg.le hf
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atTop
hg : Tendsto g l (𝓝 C)
⊢ (fun x => f x * (C / 2)) ≤ᶠ[l] fun x => f x * g x
state_after: no goals
Theorem: Complex.analyticOn_univ_iff_differentiable
File: Mathlib/Analysis/Complex/CauchyIntegral.lean

tactic: simp only [← differentiableOn_univ]
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ Differentiable ℂ f
state_after: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ DifferentiableOn ℂ f univ

tactic: exact analyticOn_iff_differentiableOn isOpen_univ
state_before: E : Type u
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
f : ℂ → E
⊢ AnalyticOn ℂ f univ ↔ DifferentiableOn ℂ f univ
state_after: no goals
Theorem: Submodule.mulLeftMap_eq_mulMap_comp
File: Mathlib/LinearAlgebra/TensorProduct/Submodule.lean

tactic: ext
state_before: R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
ι : Type u_1
inst✝ : DecidableEq ι
m : ι → ↥M
⊢ mulLeftMap N m =
    M.mulMap N ∘ₗ LinearMap.rTensor (↥N) (Finsupp.total ι (↥M) R m) ∘ₗ ↑(TensorProduct.finsuppScalarLeft R (↥N) ι).symm
state_after: case h.h
R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
ι : Type u_1
inst✝ : DecidableEq ι
m : ι → ↥M
a✝ : ι
x✝ : ↥N
⊢ (mulLeftMap N m ∘ₗ Finsupp.lsingle a✝) x✝ =
    ((M.mulMap N ∘ₗ
          LinearMap.rTensor (↥N) (Finsupp.total ι (↥M) R m) ∘ₗ ↑(TensorProduct.finsuppScalarLeft R (↥N) ι).symm) ∘ₗ
        Finsupp.lsingle a✝)
      x✝

tactic: simp
state_before: case h.h
R : Type u
S : Type v
inst✝³ : CommSemiring R
inst✝² : Semiring S
inst✝¹ : Algebra R S
M N : Submodule R S
ι : Type u_1
inst✝ : DecidableEq ι
m : ι → ↥M
a✝ : ι
x✝ : ↥N
⊢ (mulLeftMap N m ∘ₗ Finsupp.lsingle a✝) x✝ =
    ((M.mulMap N ∘ₗ
          LinearMap.rTensor (↥N) (Finsupp.total ι (↥M) R m) ∘ₗ ↑(TensorProduct.finsuppScalarLeft R (↥N) ι).symm) ∘ₗ
        Finsupp.lsingle a✝)
      x✝
state_after: no goals
Theorem: diff_mem_nhdsWithin_diff
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin, diff_eq, diff_eq, ← inf_principal, ← inf_assoc]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
x : α
s t : Set α
hs : s ∈ 𝓝[t] x
t' : Set α
⊢ s \ t' ∈ 𝓝[t \ t'] x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
x : α
s t : Set α
hs : s ∈ 𝓝[t] x
t' : Set α
⊢ s ∩ t'ᶜ ∈ 𝓝 x ⊓ 𝓟 t ⊓ 𝓟 t'ᶜ

tactic: exact inter_mem_inf hs (mem_principal_self _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : TopologicalSpace α
x : α
s t : Set α
hs : s ∈ 𝓝[t] x
t' : Set α
⊢ s ∩ t'ᶜ ∈ 𝓝 x ⊓ 𝓟 t ⊓ 𝓟 t'ᶜ
state_after: no goals
Theorem: Subtype.preimage_coe_nonempty
File: Mathlib/Data/Set/Image.lean

tactic: rw [← image_preimage_coe, image_nonempty]
state_before: α : Type u_1
s t : Set α
⊢ (val ⁻¹' t).Nonempty ↔ (s ∩ t).Nonempty
state_after: no goals
Theorem: HasDerivAtFilter.sum
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

tactic: simpa [ContinuousLinearMap.sum_apply] using (HasFDerivAtFilter.sum h).hasDerivAtFilter
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
ι : Type u_1
u : Finset ι
A : ι → 𝕜 → F
A' : ι → F
h : ∀ i ∈ u, HasDerivAtFilter (A i) (A' i) x L
⊢ HasDerivAtFilter (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x L
state_after: no goals
Theorem: LSeries.term_smul
File: Mathlib/NumberTheory/LSeries/Linearity.lean

tactic: ext ⟨- | n⟩
state_before: f : ℕ → ℂ
c s : ℂ
⊢ term (c • f) s = c • term f s
state_after: case h.zero
f : ℕ → ℂ
c s : ℂ
⊢ term (c • f) s 0 = (c • term f s) 0

case h.succ
f : ℕ → ℂ
c s : ℂ
n✝ : ℕ
⊢ term (c • f) s (n✝ + 1) = (c • term f s) (n✝ + 1)

tactic: simp only [Nat.zero_eq, term_zero, Pi.smul_apply, smul_eq_mul, mul_zero]
state_before: case h.zero
f : ℕ → ℂ
c s : ℂ
⊢ term (c • f) s 0 = (c • term f s) 0
state_after: no goals

tactic: simp only [term_of_ne_zero (Nat.succ_ne_zero _), Pi.smul_apply, smul_eq_mul, Nat.cast_succ,
  mul_div_assoc]
state_before: case h.succ
f : ℕ → ℂ
c s : ℂ
n✝ : ℕ
⊢ term (c • f) s (n✝ + 1) = (c • term f s) (n✝ + 1)
state_after: no goals
Theorem: Set.mapsTo_iInter₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [mapsTo_iInter]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : Set α
t : (i : ι) → κ i → Set β
f : α → β
⊢ MapsTo f s (⋂ i, ⋂ j, t i j) ↔ ∀ (i : ι) (j : κ i), MapsTo f s (t i j)
state_after: no goals
Theorem: IntervalIntegrable.mul_continuousOn
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [intervalIntegrable_iff] at hf ⊢
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntervalIntegrable f μ a b
hg : ContinuousOn g [[a, b]]
⊢ IntervalIntegrable (fun x => f x * g x) μ a b
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntegrableOn f (Ι a b) μ
hg : ContinuousOn g [[a, b]]
⊢ IntegrableOn (fun x => f x * g x) (Ι a b) μ

tactic: exact hf.mul_continuousOn_of_subset hg measurableSet_Ioc isCompact_uIcc Ioc_subset_Icc_self
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f✝ g✝ : ℝ → E
a b : ℝ
μ : Measure ℝ
f g : ℝ → A
hf : IntegrableOn f (Ι a b) μ
hg : ContinuousOn g [[a, b]]
⊢ IntegrableOn (fun x => f x * g x) (Ι a b) μ
state_after: no goals
Theorem: PEquiv.mul_toPEquiv_toMatrix
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: rw [PEquiv.matrix_mul_apply, ← Equiv.toPEquiv_symm, Equiv.toPEquiv_apply,
  Matrix.submatrix_apply, id]
state_before: k : Type u_1
l : Type u_2
m✝ : Type u_3
n✝ : Type u_4
α✝ : Type v
m : Type u_5
n : Type u_6
α : Type u_7
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : Semiring α
f : n ≃ n
M : Matrix m n α
i : m
j : n
⊢ (M * f.toPEquiv.toMatrix) i j = M.submatrix id (⇑f.symm) i j
state_after: no goals
Theorem: xor_not_right
File: Mathlib/Logic/Basic.lean

tactic: by_cases a <;> simp [*]
state_before: a b : Prop
⊢ Xor' a ¬b ↔ (a ↔ b)
state_after: no goals
Theorem: Filter.map₂_left_comm
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_swap m', map₂_swap m]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ m f (map₂ n g h) = map₂ n' g (map₂ m' f h)
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)

tactic: exact map₂_assoc fun _ _ _ => h_left_comm _ _ _
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → δ → ε
n : β → γ → δ
m' : α → γ → δ'
n' : β → δ' → ε
h_left_comm : ∀ (a : α) (b : β) (c : γ), m a (n b c) = n' b (m' a c)
⊢ map₂ (fun a b => m b a) (map₂ n g h) f = map₂ n' g (map₂ (fun a b => m' b a) h f)
state_after: no goals
Theorem: div_eq_inv_mul
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a / b = b⁻¹ * a
state_after: no goals
Theorem: LinearEquiv.isUnit_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: apply isUnit_det_of_left_inverse
state_before: R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ IsUnit ((toMatrix v v') ↑f).det
state_after: case h
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ ?B * (toMatrix v v') ↑f = 1

case B
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ Matrix ι ι R

tactic: simpa using (LinearMap.toMatrix_comp v v' v f.symm f).symm
state_before: case h
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ ?B * (toMatrix v v') ↑f = 1

case B
R : Type u_1
inst✝⁶ : CommRing R
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
M' : Type u_3
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
ι : Type u_4
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
e : Basis ι R M
f : M ≃ₗ[R] M'
v : Basis ι R M
v' : Basis ι R M'
⊢ Matrix ι ι R
state_after: no goals
Theorem: nndist_edist
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: simp [edist_nndist]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y : α
⊢ nndist x y = (edist x y).toNNReal
state_after: no goals
Theorem: Batteries.RBNode.Path.ins_eq_fill
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: unfold ins
state_before: α : Type u_1
c₀ : RBColor
n₀ : Nat
c : RBColor
n✝ : Nat
path : Path α
t : RBNode α
n : Nat
x✝ : RBNode α
v✝ : α
parent✝ : Path α
ha : x✝.Balanced black n
H : Path.Balanced c₀ n₀ parent✝ red n
hb : t.Balanced black n
⊢ (right red x✝ v✝ parent✝).ins t = ((right red x✝ v✝ parent✝).fill t).setBlack
state_after: α : Type u_1
c₀ : RBColor
n₀ : Nat
c : RBColor
n✝ : Nat
path : Path α
t : RBNode α
n : Nat
x✝ : RBNode α
v✝ : α
parent✝ : Path α
ha : x✝.Balanced black n
H : Path.Balanced c₀ n₀ parent✝ red n
hb : t.Balanced black n
⊢ parent✝.ins (node red x✝ v✝ t) = ((right red x✝ v✝ parent✝).fill t).setBlack

tactic: exact ins_eq_fill H (.red ha hb)
state_before: α : Type u_1
c₀ : RBColor
n₀ : Nat
c : RBColor
n✝ : Nat
path : Path α
t : RBNode α
n : Nat
x✝ : RBNode α
v✝ : α
parent✝ : Path α
ha : x✝.Balanced black n
H : Path.Balanced c₀ n₀ parent✝ red n
hb : t.Balanced black n
⊢ parent✝.ins (node red x✝ v✝ t) = ((right red x✝ v✝ parent✝).fill t).setBlack
state_after: no goals

tactic: rw [ins, fill, ← ins_eq_fill H (.black ha hb), balance1_eq ha]
state_before: α : Type u_1
c₀ : RBColor
n₀ : Nat
c✝ : RBColor
n✝ : Nat
path : Path α
t : RBNode α
n : Nat
c : RBColor
y✝ : RBNode α
c₂✝ : RBColor
parent✝ : Path α
v✝ : α
hb : y✝.Balanced c₂✝ n
H : Path.Balanced c₀ n₀ parent✝ black (n + 1)
ha : t.Balanced c n
⊢ (left black parent✝ v✝ y✝).ins t = ((left black parent✝ v✝ y✝).fill t).setBlack
state_after: no goals

tactic: rw [ins, fill, ← ins_eq_fill H (.black ha hb), balance2_eq hb]
state_before: α : Type u_1
c₀ : RBColor
n₀ : Nat
c✝ : RBColor
n✝ : Nat
path : Path α
t : RBNode α
n : Nat
c : RBColor
x✝ : RBNode α
c₁✝ : RBColor
v✝ : α
parent✝ : Path α
ha : x✝.Balanced c₁✝ n
H : Path.Balanced c₀ n₀ parent✝ black (n + 1)
hb : t.Balanced c n
⊢ (right black x✝ v✝ parent✝).ins t = ((right black x✝ v✝ parent✝).fill t).setBlack
state_after: no goals
Theorem: IsRadical.of_dvd
File: Mathlib/RingTheory/Nilpotent/Basic.lean

tactic: obtain ⟨z, rfl⟩ := hxy
state_before: R : Type u_1
S : Type u_2
x✝ y✝ : R
inst✝ : CancelCommMonoidWithZero R
x y : R
hy : IsRadical y
h0 : y ≠ 0
hxy : x ∣ y
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1

tactic: refine fun w dvd ↦ ((mul_dvd_mul_iff_right <| right_ne_zero_of_mul h0).mp <| hy 2 _ ?_)
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
⊢ ∀ (x_1 : R), x ∣ x_1 ^ 2 → x ∣ x_1
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ (w * z) ^ 2

tactic: rw [mul_pow, sq z]
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ (w * z) ^ 2
state_after: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ w ^ 2 * (z * z)

tactic: exact mul_dvd_mul dvd (dvd_mul_left z z)
state_before: case intro
R : Type u_1
S : Type u_2
x✝ y : R
inst✝ : CancelCommMonoidWithZero R
x z : R
hy : IsRadical (x * z)
h0 : x * z ≠ 0
w : R
dvd : x ∣ w ^ 2
⊢ x * z ∣ w ^ 2 * (z * z)
state_after: no goals
Theorem: SimpleGraph.Subgraph.IsSpanning.card_verts
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp only [isSpanning_iff.1 h, Set.toFinset_univ]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝¹ : Fintype V
G' : G.Subgraph
inst✝ : Fintype ↑G'.verts
h : G'.IsSpanning
⊢ G'.verts.toFinset.card = Fintype.card V
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝¹ : Fintype V
G' : G.Subgraph
inst✝ : Fintype ↑G'.verts
h : G'.IsSpanning
⊢ Finset.univ.card = Fintype.card V

tactic: congr
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
inst✝¹ : Fintype V
G' : G.Subgraph
inst✝ : Fintype ↑G'.verts
h : G'.IsSpanning
⊢ Finset.univ.card = Fintype.card V
state_after: no goals
Theorem: MeasureTheory.FinStronglyMeasurable.sup
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine
  ⟨fun n => hf.approx n ⊔ hg.approx n, fun n => ?_, fun x =>
    (hf.tendsto_approx x).sup_nhds (hg.tendsto_approx x)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
⊢ FinStronglyMeasurable (f ⊔ g) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑((fun n => hf.approx n ⊔ hg.approx n) n)) < ⊤

tactic: refine (measure_mono (support_sup _ _)).trans_lt ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑((fun n => hf.approx n ⊔ hg.approx n) n)) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑(hf.approx n) ∪ support ↑(hg.approx n)) < ⊤

tactic: exact measure_union_lt_top_iff.mpr ⟨hf.fin_support_approx n, hg.fin_support_approx n⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝⁴ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝³ : TopologicalSpace β
inst✝² : Zero β
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
hf : FinStronglyMeasurable f μ
hg : FinStronglyMeasurable g μ
n : ℕ
⊢ μ (support ↑(hf.approx n) ∪ support ↑(hg.approx n)) < ⊤
state_after: no goals
Theorem: Nat.mul_div_cancel_left'
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [Nat.mul_comm, Nat.div_mul_cancel Hd]
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
Hd : a ∣ b
⊢ a * (b / a) = b
state_after: no goals
Theorem: Corners.mk_mem_triangleIndices
File: Mathlib/Combinatorics/Additive/Corner/Roth.lean

tactic: simp only [triangleIndices, Prod.ext_iff, mem_map, Embedding.coeFn_mk, exists_prop, Prod.exists,
  eq_comm]
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
⊢ (a, b, c) ∈ Corners.triangleIndices A ↔ (a, b) ∈ A ∧ c = a + b
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
⊢ (∃ a_1 b_1, (a_1, b_1) ∈ A ∧ a = a_1 ∧ b = b_1 ∧ c = a_1 + b_1) ↔ (a, b) ∈ A ∧ c = a + b

tactic: refine ⟨?_, fun h ↦ ⟨_, _, h.1, rfl, rfl, h.2⟩⟩
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
⊢ (∃ a_1 b_1, (a_1, b_1) ∈ A ∧ a = a_1 ∧ b = b_1 ∧ c = a_1 + b_1) ↔ (a, b) ∈ A ∧ c = a + b
state_after: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
⊢ (∃ a_1 b_1, (a_1, b_1) ∈ A ∧ a = a_1 ∧ b = b_1 ∧ c = a_1 + b_1) → (a, b) ∈ A ∧ c = a + b

tactic: rintro ⟨_, _, h₁, rfl, rfl, h₂⟩
state_before: G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
⊢ (∃ a_1 b_1, (a_1, b_1) ∈ A ∧ a = a_1 ∧ b = b_1 ∧ c = a_1 + b_1) → (a, b) ∈ A ∧ c = a + b
state_after: case intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
h₁ : (a, b) ∈ A
h₂ : c = a + b
⊢ (a, b) ∈ A ∧ c = a + b

tactic: exact ⟨h₁, h₂⟩
state_before: case intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : Fintype G
A B : Finset (G × G)
a b c d x y : G
n : ℕ
ε : ℝ
h₁ : (a, b) ∈ A
h₂ : c = a + b
⊢ (a, b) ∈ A ∧ c = a + b
state_after: no goals
Theorem: Polynomial.modByMonic_zero
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: haveI := monic_zero_iff_subsingleton.mp h
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this : DecidableEq R := Classical.decEq R
h : Monic 0
⊢ p %ₘ 0 = p
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this✝ : DecidableEq R := Classical.decEq R
h : Monic 0
this : Subsingleton R
⊢ p %ₘ 0 = p

tactic: simp [eq_iff_true_of_subsingleton]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this✝ : DecidableEq R := Classical.decEq R
h : Monic 0
this : Subsingleton R
⊢ p %ₘ 0 = p
state_after: no goals

tactic: unfold modByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this : DecidableEq R := Classical.decEq R
h : ¬Monic 0
⊢ p %ₘ 0 = p
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this : DecidableEq R := Classical.decEq R
h : ¬Monic 0
⊢ (if h : Monic 0 then
      (if h_1 : degree 0 ≤ p.degree ∧ p ≠ 0 then
          let z := C p.leadingCoeff * X ^ (p.natDegree - natDegree 0);
          let_fun _wf := ⋯;
          let dm := (p - 0 * z).divModByMonicAux ⋯;
          (z + dm.1, dm.2)
        else (0, p)).2
    else p) =
    p

tactic: rw [dif_neg h]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
this : DecidableEq R := Classical.decEq R
h : ¬Monic 0
⊢ (if h : Monic 0 then
      (if h_1 : degree 0 ≤ p.degree ∧ p ≠ 0 then
          let z := C p.leadingCoeff * X ^ (p.natDegree - natDegree 0);
          let_fun _wf := ⋯;
          let dm := (p - 0 * z).divModByMonicAux ⋯;
          (z + dm.1, dm.2)
        else (0, p)).2
    else p) =
    p
state_after: no goals
Theorem: Algebra.lmul_isUnit_iff
File: Mathlib/Algebra/Algebra/Bilinear.lean

tactic: rw [Module.End_isUnit_iff, Iff.comm]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit ((Algebra.lmul R A) x) ↔ IsUnit x
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit x ↔ Function.Bijective ⇑((Algebra.lmul R A) x)

tactic: exact IsUnit.isUnit_iff_mulLeft_bijective
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
x : A
⊢ IsUnit x ↔ Function.Bijective ⇑((Algebra.lmul R A) x)
state_after: no goals
Theorem: Submonoid.mem_closure_inv
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

tactic: rw [closure_inv, mem_inv]
state_before: α : Type u_1
G✝ : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
G : Type u_6
inst✝ : Group G
S : Set G
x : G
⊢ x ∈ closure S⁻¹ ↔ x⁻¹ ∈ closure S
state_after: no goals