tasksource/leandojo huggingface dataset:
Theorem: Finsupp.embDomain_eq_mapDomain
File: Mathlib/Data/Finsupp/Basic.lean

tactic: ext a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.226928
ι : Type ?u.226931
M : Type u_3
M' : Type ?u.226937
N : Type ?u.226940
P : Type ?u.226943
G : Type ?u.226946
H : Type ?u.226949
R : Type ?u.226952
S : Type ?u.226955
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
⊢ embDomain f v = mapDomain (↑f) v

tactic: by_cases h : a ∈ Set.range f
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.226928
ι : Type ?u.226931
M : Type u_3
M' : Type ?u.226937
N : Type ?u.226940
P : Type ?u.226943
G : Type ?u.226946
H : Type ?u.226949
R : Type ?u.226952
S : Type ?u.226955
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
⊢ ↑(embDomain f v) a = ↑(mapDomain (↑f) v) a

tactic: rcases h with ⟨a, rfl⟩
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.226928
ι : Type ?u.226931
M : Type u_3
M' : Type ?u.226937
N : Type ?u.226940
P : Type ?u.226943
G : Type ?u.226946
H : Type ?u.226949
R : Type ?u.226952
S : Type ?u.226955
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
h : a ∈ Set.range ↑f
⊢ ↑(embDomain f v) a = ↑(mapDomain (↑f) v) a

tactic: rw [mapDomain_apply f.injective, embDomain_apply]
state_before: case pos.intro
α : Type u_1
β : Type u_2
γ : Type ?u.226928
ι : Type ?u.226931
M : Type u_3
M' : Type ?u.226937
N : Type ?u.226940
P : Type ?u.226943
G : Type ?u.226946
H : Type ?u.226949
R : Type ?u.226952
S : Type ?u.226955
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : α
⊢ ↑(embDomain f v) (↑f a) = ↑(mapDomain (↑f) v) (↑f a)

tactic: rw [mapDomain_notin_range, embDomain_notin_range] <;> assumption
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.226928
ι : Type ?u.226931
M : Type u_3
M' : Type ?u.226937
N : Type ?u.226940
P : Type ?u.226943
G : Type ?u.226946
H : Type ?u.226949
R : Type ?u.226952
S : Type ?u.226955
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
h : ¬a ∈ Set.range ↑f
⊢ ↑(embDomain f v) a = ↑(mapDomain (↑f) v) a
Theorem: Cubic.prod_X_sub_C_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [← one_mul <| X - C x, ← C_1, C_mul_prod_X_sub_C_eq, one_mul, one_mul, one_mul]
state_before: R : Type ?u.180963
S : Type u_1
F : Type ?u.180969
K : Type ?u.180972
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝¹ : Semiring R
inst✝ : CommRing S
x y z : S
⊢ (X - ↑C x) * (X - ↑C y) * (X - ↑C z) =
    toPoly { a := 1, b := -(x + y + z), c := x * y + x * z + y * z, d := -(x * y * z) }
Theorem: CategoryTheory.Limits.IsLimit.OfNatIso.cone_fac
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [← coneOfHom_homOfCone h s]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h s) = s

tactic: conv_lhs => simp only [homOfCone_coneOfHom]
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h (coneOfHom h (homOfCone h s))) = coneOfHom h (homOfCone h s)

tactic: apply (coneOfHom_fac _ _).symm
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h s) = coneOfHom h (homOfCone h s)
Theorem: Complex.differentiableOn_tsum_of_summable_norm
File: Mathlib/Analysis/Complex/LocallyUniformLimit.lean

tactic: classical
have hc := (tendstoUniformlyOn_tsum hu hF_le).tendstoLocallyUniformlyOn
refine' hc.differentiableOn (eventually_of_forall fun s => _) hU
exact DifferentiableOn.sum fun i _ => hf i
state_before: E : Type u_2
ι : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
u : ι → ℝ
hu : Summable u
hf : ∀ (i : ι), DifferentiableOn ℂ (F i) U
hU : IsOpen U
hF_le : ∀ (i : ι) (w : ℂ), w ∈ U → ‖F i w‖ ≤ u i
⊢ DifferentiableOn ℂ (fun w => ∑' (i : ι), F i w) U

tactic: have hc := (tendstoUniformlyOn_tsum hu hF_le).tendstoLocallyUniformlyOn
state_before: E : Type u_2
ι : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
u : ι → ℝ
hu : Summable u
hf : ∀ (i : ι), DifferentiableOn ℂ (F i) U
hU : IsOpen U
hF_le : ∀ (i : ι) (w : ℂ), w ∈ U → ‖F i w‖ ≤ u i
⊢ DifferentiableOn ℂ (fun w => ∑' (i : ι), F i w) U

tactic: refine' hc.differentiableOn (eventually_of_forall fun s => _) hU
state_before: E : Type u_2
ι : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
u : ι → ℝ
hu : Summable u
hf : ∀ (i : ι), DifferentiableOn ℂ (F i) U
hU : IsOpen U
hF_le : ∀ (i : ι) (w : ℂ), w ∈ U → ‖F i w‖ ≤ u i
hc : TendstoLocallyUniformlyOn (fun t x => Finset.sum t fun n => F n x) (fun x => ∑' (n : ι), F n x) atTop U
⊢ DifferentiableOn ℂ (fun w => ∑' (i : ι), F i w) U

tactic: exact DifferentiableOn.sum fun i _ => hf i
state_before: E : Type u_2
ι : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
u : ι → ℝ
hu : Summable u
hf : ∀ (i : ι), DifferentiableOn ℂ (F i) U
hU : IsOpen U
hF_le : ∀ (i : ι) (w : ℂ), w ∈ U → ‖F i w‖ ≤ u i
hc : TendstoLocallyUniformlyOn (fun t x => Finset.sum t fun n => F n x) (fun x => ∑' (n : ι), F n x) atTop U
s : Finset ι
⊢ DifferentiableOn ℂ (fun x => Finset.sum s fun n => F n x) U
Theorem: iInf_inf
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iInf_inf_eq, iInf_const]
state_before: α : Type u_2
β : Type ?u.102017
β₂ : Type ?u.102020
γ : Type ?u.102023
ι : Sort u_1
ι' : Sort ?u.102029
κ : ι → Sort ?u.102034
κ' : ι' → Sort ?u.102039
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ (⨅ (x : ι), f x) ⊓ a = ⨅ (x : ι), f x ⊓ a
Theorem: lineMap_mono_left
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: simp only [lineMap_apply_module]
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.2241
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a ≤ a'
hr : r ≤ 1
⊢ ↑(lineMap a b) r ≤ ↑(lineMap a' b) r

tactic: exact add_le_add_right (smul_le_smul_of_nonneg ha (sub_nonneg.2 hr)) _
state_before: k : Type u_2
E : Type u_1
PE : Type ?u.2241
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
ha : a ≤ a'
hr : r ≤ 1
⊢ (1 - r) • a + r • b ≤ (1 - r) • a' + r • b
Theorem: Matrix.add_mulVec
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.856830
m : Type u_2
n : Type u_1
o : Type ?u.856839
m' : o → Type ?u.856844
n' : o → Type ?u.856849
R : Type ?u.856852
S : Type ?u.856855
α : Type v
β : Type w
γ : Type ?u.856862
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A B : Matrix m n α
x : n → α
⊢ mulVec (A + B) x = mulVec A x + mulVec B x

tactic: apply add_dotProduct
state_before: case h
l : Type ?u.856830
m : Type u_2
n : Type u_1
o : Type ?u.856839
m' : o → Type ?u.856844
n' : o → Type ?u.856849
R : Type ?u.856852
S : Type ?u.856855
α : Type v
β : Type w
γ : Type ?u.856862
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype n
A B : Matrix m n α
x : n → α
x✝ : m
⊢ mulVec (A + B) x x✝ = (mulVec A x + mulVec B x) x✝
Theorem: ne_of_beq_false
File: src/lean/Init/Core.lean

tactic: intro h'
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
h : (a == b) = false
⊢ a ≠ b

tactic: subst h'
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
h : (a == b) = false
h' : a = b
⊢ False

tactic: have : true = false := Eq.trans LawfulBEq.rfl.symm h
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
h : (a == a) = false
⊢ False

tactic: contradiction
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
h : (a == a) = false
this : true = false
⊢ False
Theorem: PNat.exists_eq_succ_of_ne_one
File: Mathlib/Data/PNat/Basic.lean

tactic: simp
state_before: n : ℕ
property✝ : 0 < n + 2
x✝ : { val := n + 2, property := property✝ } ≠ 1
⊢ 0 < n + 1
Theorem: IsLocalization.surj_of_gcd_domain
File: Mathlib/Algebra/GCDMonoid/IntegrallyClosed.lean

tactic: obtain ⟨x, ⟨y, hy⟩, rfl⟩ := IsLocalization.mk'_surjective M z
state_before: R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
z : A
⊢ ∃ a b, IsUnit (gcd a b) ∧ z * ↑(algebraMap R A) b = ↑(algebraMap R A) a

tactic: obtain ⟨x', y', hx', hy', hu⟩ := extract_gcd x y
state_before: case intro.intro.mk
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
⊢ ∃ a b, IsUnit (gcd a b) ∧ mk' A x { val := y, property := hy } * ↑(algebraMap R A) b = ↑(algebraMap R A) a

tactic: use x', y', hu
state_before: case intro.intro.mk.intro.intro.intro.intro
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
x' y' : R
hx' : x = gcd x y * x'
hy' : y = gcd x y * y'
hu : IsUnit (gcd x' y')
⊢ ∃ a b, IsUnit (gcd a b) ∧ mk' A x { val := y, property := hy } * ↑(algebraMap R A) b = ↑(algebraMap R A) a

tactic: rw [mul_comm, IsLocalization.mul_mk'_eq_mk'_of_mul]
state_before: case intro.intro.mk.intro.intro.intro.intro
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
x' y' : R
hx' : x = gcd x y * x'
hy' : y = gcd x y * y'
hu : IsUnit (gcd x' y')
⊢ mk' A x { val := y, property := hy } * ↑(algebraMap R A) y' = ↑(algebraMap R A) x'

tactic: convert IsLocalization.mk'_mul_cancel_left (M := M) (S := A) _ _ using 2
state_before: case intro.intro.mk.intro.intro.intro.intro
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
x' y' : R
hx' : x = gcd x y * x'
hy' : y = gcd x y * y'
hu : IsUnit (gcd x' y')
⊢ mk' A (y' * x) { val := y, property := hy } = ↑(algebraMap R A) x'

tactic: rw [Subtype.coe_mk, hy', ← mul_comm y', mul_assoc]
state_before: case h.e'_2.h.e'_8
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
x' y' : R
hx' : x = gcd x y * x'
hy' : y = gcd x y * y'
hu : IsUnit (gcd x' y')
⊢ y' * x = ↑{ val := y, property := hy } * x'

tactic: conv_lhs => rw [hx']
state_before: case h.e'_2.h.e'_8
R : Type u_1
A : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : GCDMonoid R
inst✝² : CommRing A
inst✝¹ : Algebra R A
M : Submonoid R
inst✝ : IsLocalization M A
x y : R
hy : y ∈ M
x' y' : R
hx' : x = gcd x y * x'
hy' : y = gcd x y * y'
hu : IsUnit (gcd x' y')
⊢ y' * x = y' * (gcd x y * x')
Theorem: Real.cos_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← cos_neg, neg_sub, cos_sub_pi_div_two]
state_before: x : ℝ
⊢ cos (π / 2 - x) = sin x
Theorem: Finset.SupIndep.biUnion
File: Mathlib/Order/SupIndep.lean

tactic: rw [← sup_eq_biUnion]
state_before: α : Type u_3
β : Type ?u.22024
ι : Type u_1
ι' : Type u_2
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
inst✝ : DecidableEq ι
s : Finset ι'
g : ι' → Finset ι
f : ι → α
hs : SupIndep s fun i => Finset.sup (g i) f
hg : ∀ (i' : ι'), i' ∈ s → SupIndep (g i') f
⊢ SupIndep (Finset.biUnion s g) f

tactic: exact hs.sup hg
state_before: α : Type u_3
β : Type ?u.22024
ι : Type u_1
ι' : Type u_2
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
s✝ : Finset ι
f✝ : ι → α
inst✝ : DecidableEq ι
s : Finset ι'
g : ι' → Finset ι
f : ι → α
hs : SupIndep s fun i => Finset.sup (g i) f
hg : ∀ (i' : ι'), i' ∈ s → SupIndep (g i') f
⊢ SupIndep (Finset.sup s g) f
Theorem: Int.card_fintype_Ioo_of_lt
File: Mathlib/Data/Int/Interval.lean

tactic: rw [card_fintype_Ioo, sub_sub, toNat_sub_of_le h]
state_before: a b : ℤ
h : a < b
⊢ ↑(Fintype.card ↑(Set.Ioo a b)) = b - a - 1
Theorem: LinearPMap.inverse_range
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: rw [inverse, Submodule.toLinearPMap_range, ← graph_map_fst_eq_domain,
  ← LinearEquiv.snd_comp_prodComm, Submodule.map_comp]
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.710645
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ LinearMap.range (inverse hf).toFun = f.domain

tactic: rfl
state_before: R : Type u_2
inst✝⁶ : Ring R
E : Type u_1
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.710645
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f : E →ₗ.[R] F
hf : LinearMap.ker f.toFun = ⊥
⊢ Submodule.map (LinearMap.snd R F E) (Submodule.map (LinearEquiv.prodComm R E F) (graph f)) =
    Submodule.map (LinearMap.snd R F E) (Submodule.map (↑(LinearEquiv.prodComm R E F)) (graph f))
Theorem: RingHom.IsIntegral.to_finite
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: letI := f.toAlgebra
state_before: R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
h' : FiniteType f
⊢ Finite f

tactic: obtain ⟨s, hs⟩ := h'
state_before: R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
h' : FiniteType f
this : Algebra R S := toAlgebra f
⊢ Finite f

tactic: constructor
state_before: case mk.intro
R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
this : Algebra R S := toAlgebra f
s : Finset S
hs : Algebra.adjoin R ↑s = ⊤
⊢ Finite f

tactic: change (⊤ : Subalgebra R S).toSubmodule.FG
state_before: case mk.intro.out
R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
this : Algebra R S := toAlgebra f
s : Finset S
hs : Algebra.adjoin R ↑s = ⊤
⊢ FG ⊤

tactic: rw [← hs]
state_before: case mk.intro.out
R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
this : Algebra R S := toAlgebra f
s : Finset S
hs : Algebra.adjoin R ↑s = ⊤
⊢ FG (↑Subalgebra.toSubmodule ⊤)

tactic: exact FG_adjoin_of_finite (Set.toFinite _) fun x _ => h x
state_before: case mk.intro.out
R : Type u_1
A : Type ?u.599454
B : Type ?u.599457
S : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
h : IsIntegral f
this : Algebra R S := toAlgebra f
s : Finset S
hs : Algebra.adjoin R ↑s = ⊤
⊢ FG (↑Subalgebra.toSubmodule (Algebra.adjoin R ↑s))
Theorem: IsFractionRing.mk'_eq_zero_iff_eq_zero
File: Mathlib/RingTheory/Localization/FractionRing.lean

tactic: refine' ⟨fun hxy => _, fun h => by rw [h, mk'_zero]⟩
state_before: R : Type u_1
inst✝¹³ : CommRing R
M : Submonoid R
S : Type ?u.217929
inst✝¹² : CommRing S
inst✝¹¹ : Algebra R S
P : Type ?u.218166
inst✝¹⁰ : CommRing P
A : Type ?u.218172
inst✝⁹ : CommRing A
inst✝⁸ : IsDomain A
K : Type u_2
B : Type ?u.218349
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Field K
L : Type ?u.218526
inst✝⁴ : Field L
inst✝³ : Algebra A K
inst✝² : IsFractionRing A K
g : A →+* L
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : R
y : { x // x ∈ nonZeroDivisors R }
⊢ mk' K x y = 0 ↔ x = 0

tactic: rw [h, mk'_zero]
state_before: R : Type u_1
inst✝¹³ : CommRing R
M : Submonoid R
S : Type ?u.217929
inst✝¹² : CommRing S
inst✝¹¹ : Algebra R S
P : Type ?u.218166
inst✝¹⁰ : CommRing P
A : Type ?u.218172
inst✝⁹ : CommRing A
inst✝⁸ : IsDomain A
K : Type u_2
B : Type ?u.218349
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Field K
L : Type ?u.218526
inst✝⁴ : Field L
inst✝³ : Algebra A K
inst✝² : IsFractionRing A K
g : A →+* L
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : R
y : { x // x ∈ nonZeroDivisors R }
h : x = 0
⊢ mk' K x y = 0

tactic: simp_rw [mk'_eq_zero_iff, mul_left_coe_nonZeroDivisors_eq_zero_iff] at hxy
state_before: R : Type u_1
inst✝¹³ : CommRing R
M : Submonoid R
S : Type ?u.217929
inst✝¹² : CommRing S
inst✝¹¹ : Algebra R S
P : Type ?u.218166
inst✝¹⁰ : CommRing P
A : Type ?u.218172
inst✝⁹ : CommRing A
inst✝⁸ : IsDomain A
K : Type u_2
B : Type ?u.218349
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Field K
L : Type ?u.218526
inst✝⁴ : Field L
inst✝³ : Algebra A K
inst✝² : IsFractionRing A K
g : A →+* L
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : R
y : { x // x ∈ nonZeroDivisors R }
hxy : mk' K x y = 0
⊢ x = 0

tactic: exact (exists_const _).mp hxy
state_before: R : Type u_1
inst✝¹³ : CommRing R
M : Submonoid R
S : Type ?u.217929
inst✝¹² : CommRing S
inst✝¹¹ : Algebra R S
P : Type ?u.218166
inst✝¹⁰ : CommRing P
A : Type ?u.218172
inst✝⁹ : CommRing A
inst✝⁸ : IsDomain A
K : Type u_2
B : Type ?u.218349
inst✝⁷ : CommRing B
inst✝⁶ : IsDomain B
inst✝⁵ : Field K
L : Type ?u.218526
inst✝⁴ : Field L
inst✝³ : Algebra A K
inst✝² : IsFractionRing A K
g : A →+* L
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : R
y : { x // x ∈ nonZeroDivisors R }
hxy : ∃ m, x = 0
⊢ x = 0
Theorem: MeasureTheory.Measure.univ_pi_Iio_ae_eq_Iic
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [← pi_univ_Iic]
state_before: ι : Type u_2
ι' : Type ?u.3602771
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (Set.pi univ fun i => Iio (f i)) =ᶠ[ae (Measure.pi μ)] Iic f

tactic: exact pi_Iio_ae_eq_pi_Iic
state_before: ι : Type u_2
ι' : Type ?u.3602771
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (Set.pi univ fun i => Iio (f i)) =ᶠ[ae (Measure.pi μ)] Set.pi univ fun i => Iic (f i)
Theorem: dist_lineMap_left
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [← dist_zero_right, ← dist_lineMap_lineMap, lineMap_apply_zero]
state_before: α : Type ?u.29402
V : Type u_3
P : Type u_1
W : Type ?u.29411
Q : Type ?u.29414
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist (↑(lineMap p₁ p₂) c) p₁ = ‖c‖ * dist p₁ p₂
Theorem: Real.Angle.tan_coe
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [tan, sin_coe, cos_coe, Real.tan_eq_sin_div_cos]
state_before: x : ℝ
⊢ tan ↑x = Real.tan x
Theorem: CategoryTheory.HasLiftingProperty.iff_of_arrow_iso_right
File: Mathlib/CategoryTheory/LiftingProperties/Basic.lean

tactic: constructor <;> intro
state_before: C : Type u_2
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
⊢ HasLiftingProperty i p ↔ HasLiftingProperty i p'

tactic: exacts [of_arrow_iso_right i e, of_arrow_iso_right i e.symm]
state_before: case mp
C : Type u_2
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p
⊢ HasLiftingProperty i p'

case mpr
C : Type u_2
inst✝ : Category C
A✝ B✝ B' X✝ Y✝ Y'✝ : C
i✝ : A✝ ⟶ B✝
i' : B✝ ⟶ B'
p✝ : X✝ ⟶ Y✝
p'✝ : Y✝ ⟶ Y'✝
A B X Y X' Y' : C
i : A ⟶ B
p : X ⟶ Y
p' : X' ⟶ Y'
e : Arrow.mk p ≅ Arrow.mk p'
a✝ : HasLiftingProperty i p'
⊢ HasLiftingProperty i p
Theorem: Nat.minSqFacProp_div
File: Mathlib/Data/Nat/Squarefree.lean

tactic: have : ∀ p, Prime p → p * p ∣ n → k * (p * p) ∣ n := fun p pp dp =>
  have :=
    (coprime_primes pk pp).2 fun e => by
      subst e
      contradiction
  (coprime_mul_iff_right.2 ⟨this, this⟩).mul_dvd_of_dvd_of_dvd dk dp
state_before: n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : MinSqFacProp (n / k) o
⊢ MinSqFacProp n o

tactic: cases' o with d
state_before: n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : MinSqFacProp (n / k) o
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
⊢ MinSqFacProp n o

tactic: subst e
state_before: n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : MinSqFacProp (n / k) o
p : ℕ
pp : Prime p
dp : p * p ∣ n
e : k = p
⊢ False

tactic: contradiction
state_before: n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
o : Option ℕ
H : MinSqFacProp (n / k) o
pp : Prime k
dp : k * k ∣ n
⊢ False

tactic: rw [MinSqFacProp, squarefree_iff_prime_squarefree] at H⊢
state_before: case none
n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
H : MinSqFacProp (n / k) none
⊢ MinSqFacProp n none

tactic: exact fun p pp dp => H p pp ((dvd_div_iff dk).2 (this _ pp dp))
state_before: case none
n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
H :
  match none with
  | none => ∀ (x : ℕ), Prime x → ¬x * x ∣ n / k
  | some d => Prime d ∧ d * d ∣ n / k ∧ ∀ (p : ℕ), Prime p → p * p ∣ n / k → d ≤ p
⊢ match none with
  | none => ∀ (x : ℕ), Prime x → ¬x * x ∣ n
  | some d => Prime d ∧ d * d ∣ n ∧ ∀ (p : ℕ), Prime p → p * p ∣ n → d ≤ p

tactic: obtain ⟨H1, H2, H3⟩ := H
state_before: case some
n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
d : ℕ
H : MinSqFacProp (n / k) (some d)
⊢ MinSqFacProp n (some d)

tactic: simp only [dvd_div_iff dk] at H2 H3
state_before: case some.intro.intro
n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
d : ℕ
H1 : Prime d
H2 : d * d ∣ n / k
H3 : ∀ (p : ℕ), Prime p → p * p ∣ n / k → d ≤ p
⊢ MinSqFacProp n (some d)

tactic: exact ⟨H1, dvd_trans (dvd_mul_left _ _) H2, fun p pp dp => H3 _ pp (this _ pp dp)⟩
state_before: case some.intro.intro
n k : ℕ
pk : Prime k
dk : k ∣ n
dkk : ¬k * k ∣ n
this : ∀ (p : ℕ), Prime p → p * p ∣ n → k * (p * p) ∣ n
d : ℕ
H1 : Prime d
H2 : k * (d * d) ∣ n
H3 : ∀ (p : ℕ), Prime p → k * (p * p) ∣ n → d ≤ p
⊢ MinSqFacProp n (some d)
Theorem: Rat.mk_eq_normalize
File: Std/Data/Rat/Lemmas.lean

tactic: simp [normalize_eq, c.gcd_eq_one]
state_before: num : Int
den : Nat
nz : den ≠ 0
c : Nat.coprime (Int.natAbs num) den
⊢ mk' num den = normalize num den
Theorem: tsub_le_iff_left
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_right, add_comm]
state_before: α : Type u_1
β : Type ?u.1063
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b ≤ c ↔ a ≤ b + c