tasksource/leandojo huggingface dataset:
Theorem: LocalHomeomorph.preimage_eventuallyEq_target_inter_preimage_inter
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [eventuallyEq_set, e.eventually_nhds _ hxe]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.35170
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
s : Set α
t : Set γ
x : α
f : α → γ
hf : ContinuousWithinAt f s x
hxe : x ∈ e.source
ht : t ∈ 𝓝 (f x)
⊢ ↑(LocalHomeomorph.symm e) ⁻¹' s =ᶠ[𝓝 (↑e x)] e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ f ⁻¹' t)

tactic: filter_upwards [e.open_source.mem_nhds hxe,
  mem_nhdsWithin_iff_eventually.mp (hf.preimage_mem_nhdsWithin ht)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.35170
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
s : Set α
t : Set γ
x : α
f : α → γ
hf : ContinuousWithinAt f s x
hxe : x ∈ e.source
ht : t ∈ 𝓝 (f x)
⊢ ∀ᶠ (x : α) in 𝓝 x,
    ↑e x ∈ ↑(LocalHomeomorph.symm e) ⁻¹' s ↔ ↑e x ∈ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ f ⁻¹' t)

tactic: intro y hy hyu
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.35170
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
s : Set α
t : Set γ
x : α
f : α → γ
hf : ContinuousWithinAt f s x
hxe : x ∈ e.source
ht : t ∈ 𝓝 (f x)
⊢ ∀ (a : α),
    a ∈ e.source →
      (a ∈ s → a ∈ f ⁻¹' t) →
        (↑e a ∈ ↑(LocalHomeomorph.symm e) ⁻¹' s ↔ ↑e a ∈ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ f ⁻¹' t))

tactic: simp_rw [mem_inter_iff, mem_preimage, mem_inter_iff, e.mapsTo hy, true_and_iff, iff_self_and,
  e.left_inv hy, iff_true_intro hyu]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.35170
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e : LocalHomeomorph α β
s : Set α
t : Set γ
x : α
f : α → γ
hf : ContinuousWithinAt f s x
hxe : x ∈ e.source
ht : t ∈ 𝓝 (f x)
y : α
hy : y ∈ e.source
hyu : y ∈ s → y ∈ f ⁻¹' t
⊢ ↑e y ∈ ↑(LocalHomeomorph.symm e) ⁻¹' s ↔ ↑e y ∈ e.target ∩ ↑(LocalHomeomorph.symm e) ⁻¹' (s ∩ f ⁻¹' t)
Theorem: RatFunc.denom_mul_dvd
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [denom_dvd (mul_ne_zero (denom_ne_zero x) (denom_ne_zero y))]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ denom (x * y) ∣ denom x * denom y

tactic: refine' ⟨x.num * y.num, _⟩
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ ∃ p, x * y = ↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)

tactic: rw [RingHom.map_mul, RingHom.map_mul, ← div_mul_div_comm, num_div_denom, num_div_denom]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
⊢ x * y = ↑(algebraMap K[X] (RatFunc K)) (num x * num y) / ↑(algebraMap K[X] (RatFunc K)) (denom x * denom y)
Theorem: PNat.factorMultiset_lcm
File: Mathlib/Data/PNat/Factors.lean

tactic: apply le_antisymm
state_before: m n : ℕ+
⊢ factorMultiset (lcm m n) = factorMultiset m ⊔ factorMultiset n

tactic: rw [← PrimeMultiset.prod_dvd_iff, prod_factorMultiset]
state_before: case a
m n : ℕ+
⊢ factorMultiset (lcm m n) ≤ factorMultiset m ⊔ factorMultiset n

tactic: apply lcm_dvd <;> rw [← factorMultiset_le_iff']
state_before: case a
m n : ℕ+
⊢ lcm m n ∣ PrimeMultiset.prod (factorMultiset m ⊔ factorMultiset n)

tactic: exact le_sup_left
state_before: case a.hm
m n : ℕ+
⊢ factorMultiset m ≤ factorMultiset m ⊔ factorMultiset n

case a.hn
m n : ℕ+
⊢ factorMultiset n ≤ factorMultiset m ⊔ factorMultiset n

tactic: exact le_sup_right
state_before: case a.hn
m n : ℕ+
⊢ factorMultiset n ≤ factorMultiset m ⊔ factorMultiset n

tactic: apply sup_le_iff.mpr
state_before: case a
m n : ℕ+
⊢ factorMultiset m ⊔ factorMultiset n ≤ factorMultiset (lcm m n)

tactic: constructor <;> apply factorMultiset_le_iff.mpr
state_before: case a
m n : ℕ+
⊢ factorMultiset m ≤ factorMultiset (lcm m n) ∧ factorMultiset n ≤ factorMultiset (lcm m n)

tactic: exact dvd_lcm_left m n
state_before: case a.left
m n : ℕ+
⊢ m ∣ lcm m n

case a.right
m n : ℕ+
⊢ n ∣ lcm m n

tactic: exact dvd_lcm_right m n
state_before: case a.right
m n : ℕ+
⊢ n ∣ lcm m n
Theorem: dist_div_div_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simpa only [div_eq_mul_inv, dist_inv_inv] using dist_mul_mul_le a₁ a₂⁻¹ b₁ b₂⁻¹
state_before: 𝓕 : Type ?u.646954
𝕜 : Type ?u.646957
α : Type ?u.646960
ι : Type ?u.646963
κ : Type ?u.646966
E : Type u_1
F : Type ?u.646972
G : Type ?u.646975
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂
Theorem: Lagrange.eval_basisDivisor_left_of_ne
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp only [basisDivisor, eval_mul, eval_C, eval_sub, eval_X]
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ eval x (basisDivisor x y) = 1

tactic: exact inv_mul_cancel (sub_ne_zero_of_ne hxy)
state_before: F : Type u_1
inst✝ : Field F
x y : F
hxy : x ≠ y
⊢ (x - y)⁻¹ * (x - y) = 1
Theorem: ENNReal.coe_inv_two
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [coe_inv _root_.two_ne_zero, coe_two]
state_before: α : Type ?u.218569
β : Type ?u.218572
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ↑2⁻¹ = 2⁻¹
Theorem: open_dom_of_pcontinuous
File: Mathlib/Topology/Partial.lean

tactic: rw [← PFun.preimage_univ]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α →. β
h : PContinuous f
⊢ IsOpen (PFun.Dom f)

tactic: exact h _ isOpen_univ
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α →. β
h : PContinuous f
⊢ IsOpen (PFun.preimage f Set.univ)
Theorem: ContinuousLinearMap.coe_ofSeqClosedGraph
File: Mathlib/Analysis/NormedSpace/Banach.lean

tactic: ext
state_before: 𝕜 : Type u_3
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
g : E →ₗ[𝕜] F
hg : ∀ (u : ℕ → E) (x : E) (y : F), Tendsto u atTop (𝓝 x) → Tendsto (↑g ∘ u) atTop (𝓝 y) → y = ↑g x
⊢ ↑(ofSeqClosedGraph hg) = g

tactic: rfl
state_before: case h
𝕜 : Type u_3
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
g : E →ₗ[𝕜] F
hg : ∀ (u : ℕ → E) (x : E) (y : F), Tendsto u atTop (𝓝 x) → Tendsto (↑g ∘ u) atTop (𝓝 y) → y = ↑g x
x✝ : E
⊢ ↑↑(ofSeqClosedGraph hg) x✝ = ↑g x✝
Theorem: Set.Subsingleton.infsep_zero
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [infsep_zero.mpr]
state_before: α : Type u_1
β : Type ?u.55704
inst✝ : EDist α
x y : α
s : Set α
hs : Set.Subsingleton s
⊢ infsep s = 0

tactic: right
state_before: α : Type u_1
β : Type ?u.55704
inst✝ : EDist α
x y : α
s : Set α
hs : Set.Subsingleton s
⊢ Set.einfsep s = 0 ∨ Set.einfsep s = ⊤

tactic: exact hs.einfsep
state_before: case h
α : Type u_1
β : Type ?u.55704
inst✝ : EDist α
x y : α
s : Set α
hs : Set.Subsingleton s
⊢ Set.einfsep s = ⊤
Theorem: CategoryTheory.MorphismProperty.RespectsIso.monomorphisms
File: Mathlib/CategoryTheory/MorphismProperty.lean

tactic: intro X Y Z e f
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.60407
inst✝ : Category D
⊢ ∀ {X Y Z : C} (e : Y ≅ Z) (f : X ⟶ Y),
    MorphismProperty.monomorphisms C f → MorphismProperty.monomorphisms C (f ≫ e.hom)

tactic: simp only [monomorphisms.iff]
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.60407
inst✝ : Category D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
⊢ MorphismProperty.monomorphisms C f → MorphismProperty.monomorphisms C (f ≫ e.hom)

tactic: intro
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.60407
inst✝ : Category D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
⊢ Mono f → Mono (f ≫ e.hom)

tactic: apply mono_comp
state_before: case right
C : Type u
inst✝¹ : Category C
D : Type ?u.60407
inst✝ : Category D
X Y Z : C
e : Y ≅ Z
f : X ⟶ Y
a✝ : Mono f
⊢ Mono (f ≫ e.hom)
Theorem: ZMod.natAbs_valMinAbs_neg
File: Mathlib/Data/ZMod/Basic.lean

tactic: by_cases h2a : 2 * a.val = n
state_before: n : ℕ
a : ZMod n
⊢ Int.natAbs (valMinAbs (-a)) = Int.natAbs (valMinAbs a)

tactic: rw [a.neg_eq_self_iff.2 (Or.inr h2a)]
state_before: case pos
n : ℕ
a : ZMod n
h2a : 2 * val a = n
⊢ Int.natAbs (valMinAbs (-a)) = Int.natAbs (valMinAbs a)

tactic: rw [valMinAbs_neg_of_ne_half h2a, Int.natAbs_neg]
state_before: case neg
n : ℕ
a : ZMod n
h2a : ¬2 * val a = n
⊢ Int.natAbs (valMinAbs (-a)) = Int.natAbs (valMinAbs a)
Theorem: RatFunc.num_mul_denom_add_denom_mul_num_ne_zero
File: Mathlib/FieldTheory/RatFunc.lean

tactic: intro h_zero
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hxy : x + y ≠ 0
⊢ num x * denom y + denom x * num y ≠ 0

tactic: have h := num_denom_add x y
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hxy : x + y ≠ 0
h_zero : num x * denom y + denom x * num y = 0
⊢ False

tactic: rw [h_zero, MulZeroClass.zero_mul] at h
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hxy : x + y ≠ 0
h_zero : num x * denom y + denom x * num y = 0
h : num (x + y) * (denom x * denom y) = (num x * denom y + denom x * num y) * denom (x + y)
⊢ False

tactic: exact (mul_ne_zero (num_ne_zero hxy) (mul_ne_zero x.denom_ne_zero y.denom_ne_zero)) h
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hxy : x + y ≠ 0
h_zero : num x * denom y + denom x * num y = 0
h : num (x + y) * (denom x * denom y) = 0
⊢ False
Theorem: PNat.find_eq_iff
File: Mathlib/Data/PNat/Find.lean

tactic: constructor
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = m ↔ p m ∧ ∀ (n : ℕ+), n < m → ¬p n

tactic: rintro rfl
state_before: case mp
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = m → p m ∧ ∀ (n : ℕ+), n < m → ¬p n

tactic: exact ⟨PNat.find_spec h, fun _ => PNat.find_min h⟩
state_before: case mp
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n : ℕ+
⊢ p (PNat.find h) ∧ ∀ (n : ℕ+), n < PNat.find h → ¬p n

tactic: rintro ⟨hm, hlt⟩
state_before: case mpr
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ (p m ∧ ∀ (n : ℕ+), n < m → ¬p n) → PNat.find h = m

tactic: exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h)
state_before: case mpr.intro
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
hm : p m
hlt : ∀ (n : ℕ+), n < m → ¬p n
⊢ PNat.find h = m
Theorem: Module.projective_lifting_property
File: Mathlib/Algebra/Module/Projective.lean

tactic: let φ : (P →₀ R) →ₗ[R] M := Finsupp.total _ _ _ fun p => Function.surjInv hf (g p)
state_before: R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
⊢ ∃ h, comp f h = g

tactic: cases' h.out with s hs
state_before: R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
φ : (P →₀ R) →ₗ[R] M := Finsupp.total P M R fun p => Function.surjInv hf (↑g p)
⊢ ∃ h, comp f h = g

tactic: use φ.comp s
state_before: case intro
R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
φ : (P →₀ R) →ₗ[R] M := Finsupp.total P M R fun p => Function.surjInv hf (↑g p)
s : P →ₗ[R] P →₀ R
hs : Function.LeftInverse ↑(Finsupp.total P P R id) ↑s
⊢ ∃ h, comp f h = g

tactic: ext p
state_before: case intro
R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
φ : (P →₀ R) →ₗ[R] M := Finsupp.total P M R fun p => Function.surjInv hf (↑g p)
s : P →ₗ[R] P →₀ R
hs : Function.LeftInverse ↑(Finsupp.total P P R id) ↑s
⊢ comp f (comp φ s) = g

tactic: conv_rhs => rw [← hs p]
state_before: case intro.h
R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
φ : (P →₀ R) →ₗ[R] M := Finsupp.total P M R fun p => Function.surjInv hf (↑g p)
s : P →ₗ[R] P →₀ R
hs : Function.LeftInverse ↑(Finsupp.total P P R id) ↑s
p : P
⊢ ↑(comp f (comp φ s)) p = ↑g p

tactic: simp [Finsupp.total_apply, Function.surjInv_eq hf]
state_before: case intro.h
R : Type u_1
inst✝⁶ : Semiring R
P : Type u_2
inst✝⁵ : AddCommMonoid P
inst✝⁴ : Module R P
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
N : Type u_4
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
h : Projective R P
f : M →ₗ[R] N
g : P →ₗ[R] N
hf : Function.Surjective ↑f
φ : (P →₀ R) →ₗ[R] M := Finsupp.total P M R fun p => Function.surjInv hf (↑g p)
s : P →ₗ[R] P →₀ R
hs : Function.LeftInverse ↑(Finsupp.total P P R id) ↑s
p : P
⊢ ↑(comp f (comp φ s)) p = ↑g (↑(Finsupp.total P P R id) (↑s p))
Theorem: Finset.filter_lt_eq_Ioi
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: ext
state_before: ι : Type ?u.61874
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderTop α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred ((fun x x_1 => x < x_1) a)
⊢ filter ((fun x x_1 => x < x_1) a) univ = Ioi a

tactic: simp
state_before: case a
ι : Type ?u.61874
α : Type u_1
inst✝³ : Preorder α
inst✝² : LocallyFiniteOrderTop α
a : α
inst✝¹ : Fintype α
inst✝ : DecidablePred ((fun x x_1 => x < x_1) a)
a✝ : α
⊢ a✝ ∈ filter ((fun x x_1 => x < x_1) a) univ ↔ a✝ ∈ Ioi a
Theorem: nhds_mul
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ 𝓝 (x * y) = map ((fun x x_1 => x * x_1) x) (map (fun a => a * y) (𝓝 1 * 𝓝 1))

tactic: rw [← map₂_mul, map_map₂, map_map₂]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map ((fun x x_1 => x * x_1) x) (map (fun a => a * y) (𝓝 1 * 𝓝 1)) = map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1)

tactic: simp only [mul_assoc]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * (a * b * y)) (𝓝 1) (𝓝 1) = map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1)

tactic: rw [← map_mul_left_nhds_one x, ← map_mul_right_nhds_one y, ← map₂_mul, map₂_map_left,
 map₂_map_right]
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
x y : G
⊢ map₂ (fun a b => x * a * (b * y)) (𝓝 1) (𝓝 1) = 𝓝 x * 𝓝 y
Theorem: IsNoetherian.iff_fg
File: Mathlib/FieldTheory/Finiteness.lean

tactic: constructor
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V ↔ Module.Finite K V

tactic: intro h
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ IsNoetherian K V → Module.Finite K V

tactic: exact
  ⟨⟨finsetBasisIndex K V, by
      convert (finsetBasis K V).span_eq
      simp⟩⟩
state_before: case mp
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ Module.Finite K V

tactic: convert (finsetBasis K V).span_eq
state_before: K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ span K ↑(finsetBasisIndex K V) = ⊤

tactic: simp
state_before: case h.e'_2.h.e'_6
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
h : IsNoetherian K V
⊢ ↑(finsetBasisIndex K V) = Set.range ↑(finsetBasis K V)

tactic: rintro ⟨s, hs⟩
state_before: case mpr
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ Module.Finite K V → IsNoetherian K V

tactic: rw [IsNoetherian.iff_rank_lt_aleph0, ← rank_top, ← hs]
state_before: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ IsNoetherian K V

tactic: exact lt_of_le_of_lt (rank_span_le _) s.finite_toSet.lt_aleph0
state_before: case mpr.mk.intro
K : Type u
V : Type v
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
s : Finset V
hs : span K ↑s = ⊤
⊢ Module.rank K { x // x ∈ span K ↑s } < ℵ₀
Theorem: Finset.inter_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [erase_eq, inter_sdiff]
state_before: α : Type u_1
β : Type ?u.261085
γ : Type ?u.261088
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ s ∩ erase t a = erase (s ∩ t) a
Theorem: bit1_zero
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [bit1, bit0_zero, zero_add]
state_before: α : Type ?u.11341
β : Type ?u.11344
G : Type ?u.11347
M : Type u
inst✝¹ : AddMonoid M
a b c : M
inst✝ : One M
⊢ bit1 0 = 1
Theorem: Cardinal.mul_eq_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [mul_comm, mul_eq_left hb ha ha']
state_before: a b : Cardinal
hb : ℵ₀ ≤ b
ha : a ≤ b
ha' : a ≠ 0
⊢ a * b = b
Theorem: Decidable.imp_or'
File: Std/Logic.lean

tactic: simp [h]
state_before: b : Prop
a : Sort u_1
c : Prop
inst✝ : Decidable b
h : b
⊢ a → b ∨ c ↔ (a → b) ∨ (a → c)

tactic: rw [eq_false h, false_or]
state_before: b : Prop
a : Sort u_1
c : Prop
inst✝ : Decidable b
h : ¬b
⊢ a → b ∨ c ↔ (a → b) ∨ (a → c)

tactic: exact (or_iff_right_of_imp fun hx x => (hx x).elim).symm
state_before: b : Prop
a : Sort u_1
c : Prop
inst✝ : Decidable b
h : ¬b
⊢ a → c ↔ (a → False) ∨ (a → c)
Theorem: List.map₂Left_eq_map₂Left'
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.465338
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as : List α
x✝ : List β
⊢ map₂Left f [] x✝ = (map₂Left' f [] x✝).fst

tactic: simp
state_before: ι : Type ?u.465338
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
⊢ map₂Left f (a :: as) [] = (map₂Left' f (a :: as) []).fst

tactic: simp [map₂Left_eq_map₂Left']
state_before: ι : Type ?u.465338
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → Option β → γ
as✝ : List α
a : α
as : List α
b : β
bs : List β
⊢ map₂Left f (a :: as) (b :: bs) = (map₂Left' f (a :: as) (b :: bs)).fst
Theorem: PadicInt.modPart_lt_p
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: convert Int.emod_lt _ _
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ modPart p r < ↑p

tactic: simp
state_before: case h.e'_4
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ ↑p = abs ↑p

tactic: exact_mod_cast hp_prime.1.ne_zero
state_before: case convert_3
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ ↑p ≠ 0
Theorem: CategoryTheory.imageUnopOp_inv_comp_op_factorThruImage
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: rw [Iso.inv_comp_eq, imageUnopOp_hom_comp_image_ι]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (imageUnopOp g).inv ≫ (factorThruImage g.unop).op = image.ι g
Theorem: ContinuousMultilinearMap.norm_restr
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: apply MultilinearMap.mkContinuous_norm_le
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n✝ : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n✝) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n✝)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n✝)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k n : ℕ
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
s : Finset (Fin n)
hk : card s = k
z : G
⊢ ‖restr f s hk z‖ ≤ ‖f‖ * ‖z‖ ^ (n - k)

tactic: exact mul_nonneg (norm_nonneg _) (pow_nonneg (norm_nonneg _) _)
state_before: case hC
𝕜 : Type u
ι : Type v
ι' : Type v'
n✝ : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n✝) → Type wEi
G : Type wG
G' : Type wG'
inst✝¹⁴ : Fintype ι
inst✝¹³ : Fintype ι'
inst✝¹² : NontriviallyNormedField 𝕜
inst✝¹¹ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁰ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁹ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁷ : (i : ι') → NormedAddCommGroup (E' i)
inst✝⁶ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝⁵ : (i : Fin (Nat.succ n✝)) → NormedAddCommGroup (Ei i)
inst✝⁴ : (i : Fin (Nat.succ n✝)) → NormedSpace 𝕜 (Ei i)
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
k n : ℕ
f : ContinuousMultilinearMap 𝕜 (fun i => G) G'
s : Finset (Fin n)
hk : card s = k
z : G
⊢ 0 ≤ ‖f‖ * ‖z‖ ^ (n - k)
Theorem: InnerProductSpace.Core.inner_zero_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_zero_left]
state_before: 𝕜 : Type u_1
E : Type ?u.536125
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ inner x 0 = 0

tactic: simp only [RingHom.map_zero]
state_before: 𝕜 : Type u_1
E : Type ?u.536125
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x : F
⊢ ↑(starRingEnd 𝕜) 0 = 0
Theorem: ProbabilityTheory.kernel.sum_add
File: Mathlib/Probability/Kernel/Basic.lean

tactic: ext a s
state_before: α : Type u_2
β : Type u_3
ι : Type u_1
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
inst✝ : Countable ι
κ η : ι → { x // x ∈ kernel α β }
⊢ (kernel.sum fun n => κ n + η n) = kernel.sum κ + kernel.sum η

tactic: intro hs
state_before: case h.h
α : Type u_2
β : Type u_3
ι : Type u_1
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
inst✝ : Countable ι
κ η : ι → { x // x ∈ kernel α β }
a : α
s : Set β
⊢ MeasurableSet s → ↑↑(↑(kernel.sum fun n => κ n + η n) a) s = ↑↑(↑(kernel.sum κ + kernel.sum η) a) s

tactic: simp only [coeFn_add, Pi.add_apply, sum_apply, Measure.sum_apply _ hs, Pi.add_apply,
  Measure.coe_add, tsum_add ENNReal.summable ENNReal.summable]
state_before: case h.h
α : Type u_2
β : Type u_3
ι : Type u_1
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : { x // x ∈ kernel α β }
inst✝ : Countable ι
κ η : ι → { x // x ∈ kernel α β }
a : α
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(kernel.sum fun n => κ n + η n) a) s = ↑↑(↑(kernel.sum κ + kernel.sum η) a) s