tasksource/leandojo huggingface dataset:
Theorem: MvPolynomial.mem_ideal_span_monomial_image_iff_dvd
File: Mathlib/RingTheory/MvPolynomial/Ideal.lean

tactic: refine' mem_ideal_span_monomial_image.trans (forall₂_congr fun xi hxi => _)
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
x : MvPolynomial σ R
s : Set (σ →₀ ℕ)
⊢ x ∈ Ideal.span ((fun s => ↑(monomial s) 1) '' s) ↔
    ∀ (xi : σ →₀ ℕ), xi ∈ support x → ∃ si, si ∈ s ∧ ↑(monomial si) 1 ∣ ↑(monomial xi) (coeff xi x)

tactic: simp_rw [monomial_dvd_monomial, one_dvd, and_true_iff, mem_support_iff.mp hxi, false_or_iff]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
x : MvPolynomial σ R
s : Set (σ →₀ ℕ)
xi : σ →₀ ℕ
hxi : xi ∈ support x
⊢ (∃ si, si ∈ s ∧ si ≤ xi) ↔ ∃ si, si ∈ s ∧ ↑(monomial si) 1 ∣ ↑(monomial xi) (coeff xi x)
Theorem: Set.biUnion_Ico_eq_Iio_self_iff
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: simp [← Ici_inter_Iio, ← iUnion_inter, subset_def]
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
⊢ (⋃ (i : ι) (hi : p i), Ico (f i hi) a) = Iio a ↔ ∀ (x : α), x < a → ∃ i hi, f i hi ≤ x
Theorem: Polynomial.natTrailingDegree_le_trailingDegree
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: by_cases hp : p = 0
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ ↑(natTrailingDegree p) ≤ trailingDegree p

tactic: rw [trailingDegree_eq_natTrailingDegree hp]
state_before: case neg
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : ¬p = 0
⊢ ↑(natTrailingDegree p) ≤ trailingDegree p

tactic: rw [hp, trailingDegree_zero]
state_before: case pos
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p = 0
⊢ ↑(natTrailingDegree p) ≤ trailingDegree p

tactic: exact le_top
state_before: case pos
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p = 0
⊢ ↑(natTrailingDegree 0) ≤ ⊤
Theorem: Complex.lipschitz_equivRealProd
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simpa using AddMonoidHomClass.lipschitz_of_bound equivRealProdLm 1 equivRealProd_apply_le'
state_before: E : Type ?u.231205
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
⊢ LipschitzWith 1 ↑equivRealProd
Theorem: intervalIntegral.inv_smul_integral_comp_add_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_add_div]
state_before: ι : Type ?u.14905629
𝕜 : Type ?u.14905632
E : Type u_1
F : Type ?u.14905638
A : Type ?u.14905641
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ (c⁻¹ • ∫ (x : ℝ) in a..b, f (d + x / c)) = ∫ (x : ℝ) in d + a / c..d + b / c, f x
Theorem: CategoryTheory.Subobject.mk_eq_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝³ : Category C
X Y Z : C
D : Type u₂
inst✝² : Category D
B A₁ A₂ : C
f : A₁ ⟶ B
g : A₂ ⟶ B
inst✝¹ : Mono f
inst✝ : Mono g
i : A₁ ≅ A₂
w : i.hom ≫ g = f
⊢ (underlyingIso f ≪≫ i).hom ≫ g = arrow (mk f)
Theorem: InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [← sq_eq_sq (norm_nonneg (x + y)) (add_nonneg (norm_nonneg x) (norm_nonneg y)),
  norm_add_pow_two_real, inner_eq_mul_norm_of_angle_eq_zero h]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
h : angle x y = 0
⊢ ‖x + y‖ = ‖x‖ + ‖y‖

tactic: ring
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
h : angle x y = 0
⊢ ‖x‖ ^ 2 + 2 * (‖x‖ * ‖y‖) + ‖y‖ ^ 2 = (‖x‖ + ‖y‖) ^ 2
Theorem: StarSubalgebra.coe_iInf
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: simp [iInf]
state_before: F : Type ?u.686964
R : Type u_2
A : Type u_3
B : Type ?u.686973
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
ι : Sort u_1
S : ι → StarSubalgebra R A
⊢ ↑(⨅ (i : ι), S i) = ⋂ (i : ι), ↑(S i)
Theorem: String.split_of_valid
File: Std/Data/String/Lemmas.lean

tactic: simpa [split] using splitAux_of_valid p [] [] s.1 []
state_before: s : String
p : Char → Bool
⊢ split s p = List.map mk (List.splitOnP p s.data)
Theorem: Sum.getLeft_map
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
f : α → β
g : γ → δ
x : α ⊕ γ
⊢ getLeft (Sum.map f g x) = Option.map f (getLeft x)
Theorem: Polynomial.X_mul
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ X * p = p * X

tactic: simp only [X, ← ofFinsupp_single, ← ofFinsupp_mul, LinearMap.coe_mk, ofFinsupp.injEq]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ X * { toFinsupp := toFinsupp✝ } = { toFinsupp := toFinsupp✝ } * X

tactic: refine Finsupp.ext fun _ => ?_
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ Finsupp.single 1 1 * toFinsupp✝ = toFinsupp✝ * Finsupp.single 1 1

tactic: simp [AddMonoidAlgebra.mul_apply, AddMonoidAlgebra.sum_single_index, add_comm]
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
x✝ : ℕ
⊢ ↑(Finsupp.single 1 1 * toFinsupp✝) x✝ = ↑(toFinsupp✝ * Finsupp.single 1 1) x✝
Theorem: BoxIntegral.HasIntegral.sub
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [sub_eq_add_neg] using h.add h'.neg
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : HasIntegral I l f vol y
h' : HasIntegral I l g vol y'
⊢ HasIntegral I l (f - g) vol (y - y')
Theorem: PowerSeries.coeff_X_pow_self
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_X_pow, if_pos rfl]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
⊢ ↑(coeff R n) (X ^ n) = 1
Theorem: Holor.cprankMax_add
File: Mathlib/Data/Holor.lean

tactic: match hx with
| CPRankMax.zero => simp only [zero_add, hy]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
n : ℕ
x y : Holor α ds
hx : CPRankMax 0 x
hy : CPRankMax n y
⊢ CPRankMax (0 + n) (x + y)

tactic: simp only [zero_add, hy]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
n : ℕ
x y : Holor α ds
hx : CPRankMax 0 x
hy : CPRankMax n y
⊢ CPRankMax (0 + n) (0 + y)

tactic: simp only [add_comm, add_assoc]
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
m n : ℕ
y x₁ x₂ : Holor α ds
hx₁ : CPRankMax1 x₁
hx₂ : CPRankMax m x₂
hy : CPRankMax n y
⊢ CPRankMax (m + 1 + n) (x₁ + x₂ + y)

tactic: apply CPRankMax.succ
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
m n : ℕ
y x₁ x₂ : Holor α ds
hx₁ : CPRankMax1 x₁
hx₂ : CPRankMax m x₂
hy : CPRankMax n y
⊢ CPRankMax (n + (m + 1)) (x₁ + (x₂ + y))

tactic: assumption
state_before: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
m n : ℕ
y x₁ x₂ : Holor α ds
hx₁ : CPRankMax1 x₁
hx₂ : CPRankMax m x₂
hy : CPRankMax n y
⊢ CPRankMax1 x₁

tactic: simp only [Nat.add_eq, add_zero, add_comm n m]
state_before: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
m n : ℕ
y x₁ x₂ : Holor α ds
hx₁ : CPRankMax1 x₁
hx₂ : CPRankMax m x₂
hy : CPRankMax n y
⊢ CPRankMax (Nat.add n (Nat.add m 0)) (x₂ + y)

tactic: exact cprankMax_add hx₂ hy
state_before: case a
α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
m n : ℕ
y x₁ x₂ : Holor α ds
hx₁ : CPRankMax1 x₁
hx₂ : CPRankMax m x₂
hy : CPRankMax n y
⊢ CPRankMax (m + n) (x₂ + y)
Theorem: Function.Antiperiodic.const_sub
File: Mathlib/Algebra/Periodic.lean

tactic: simp only [← sub_sub, h.sub_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.170605
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddCommGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a - x)) (x + c) = -(fun x => f (a - x)) x
Theorem: Nat.sub.elim
File: src/lean/Init/Data/Nat/Basic.lean

tactic: cases Nat.lt_or_ge x y with
| inl hlt => rw [Nat.sub_eq_zero_of_le (Nat.le_of_lt hlt)]; exact h₂ hlt
| inr hle => exact h₁ hle (x - y) (Nat.add_sub_of_le hle).symm
state_before: motive : Nat → Prop
x y : Nat
h₁ : y ≤ x → ∀ (k : Nat), x = y + k → motive k
h₂ : x < y → motive 0
⊢ motive (x - y)

tactic: rw [Nat.sub_eq_zero_of_le (Nat.le_of_lt hlt)]
state_before: case inl
motive : Nat → Prop
x y : Nat
h₁ : y ≤ x → ∀ (k : Nat), x = y + k → motive k
h₂ : x < y → motive 0
hlt : x < y
⊢ motive (x - y)

tactic: exact h₂ hlt
state_before: case inl
motive : Nat → Prop
x y : Nat
h₁ : y ≤ x → ∀ (k : Nat), x = y + k → motive k
h₂ : x < y → motive 0
hlt : x < y
⊢ motive 0

tactic: exact h₁ hle (x - y) (Nat.add_sub_of_le hle).symm
state_before: case inr
motive : Nat → Prop
x y : Nat
h₁ : y ≤ x → ∀ (k : Nat), x = y + k → motive k
h₂ : x < y → motive 0
hle : x ≥ y
⊢ motive (x - y)
Theorem: Dfinsupp.Lex.acc_of_single_erase
File: Mathlib/Data/Dfinsupp/WellFounded.lean

tactic: classical
  convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
    (InvImage.accessible snd <| hs.prod_gameAdd hu)
  convert piecewise_single_erase x i
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (Dfinsupp.Lex r s) (single i (↑x i))
hu : Acc (Dfinsupp.Lex r s) (erase i x)
⊢ Acc (Dfinsupp.Lex r s) x

tactic: convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
  (InvImage.accessible snd <| hs.prod_gameAdd hu)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (Dfinsupp.Lex r s) (single i (↑x i))
hu : Acc (Dfinsupp.Lex r s) (erase i x)
⊢ Acc (Dfinsupp.Lex r s) x

tactic: convert piecewise_single_erase x i
state_before: case h.e'_3
ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Zero (α i)
r : ι → ι → Prop
s : (i : ι) → α i → α i → Prop
inst✝ : DecidableEq ι
x : Π₀ (i : ι), α i
i : ι
hs : Acc (Dfinsupp.Lex r s) (single i (↑x i))
hu : Acc (Dfinsupp.Lex r s) (erase i x)
⊢ piecewise ({i}, single i (↑x i), erase i x).snd.fst ({i}, single i (↑x i), erase i x).snd.snd
      ({i}, single i (↑x i), erase i x).fst =
    x
Theorem: Sigma.Lex.mono
File: Mathlib/Data/Sigma/Lex.lean

tactic: obtain ⟨a, b, hij⟩ | ⟨a, b, hab⟩ := h
state_before: ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a✝ b✝ : (i : ι) × α i
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
a b : (i : ι) × α i
h : Lex r₁ s₁ a b
⊢ Lex r₂ s₂ a b

tactic: exact Lex.left _ _ (hr _ _ hij)
state_before: case left
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a✝ b✝ : (i : ι) × α i
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
i✝ j✝ : ι
a : α i✝
b : α j✝
hij : r₁ i✝ j✝
⊢ Lex r₂ s₂ { fst := i✝, snd := a } { fst := j✝, snd := b }

tactic: exact Lex.right _ _ (hs _ _ _ hab)
state_before: case right
ι : Type u_1
α : ι → Type u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a✝ b✝ : (i : ι) × α i
hr : ∀ (a b : ι), r₁ a b → r₂ a b
hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b
i✝ : ι
a b : α i✝
hab : s₁ i✝ a b
⊢ Lex r₂ s₂ { fst := i✝, snd := a } { fst := i✝, snd := b }
Theorem: Polynomial.card_support_eq_zero
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ Finset.card (support p) = 0 ↔ p = 0
Theorem: Set.mulIndicator_apply_ne_one
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp only [Ne.def, mulIndicator_apply_eq_one, not_imp, mem_inter_iff, mem_mulSupport]
state_before: α : Type u_2
β : Type ?u.6623
ι : Type ?u.6626
M : Type u_1
N : Type ?u.6632
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a✝ a : α
⊢ mulIndicator s f a ≠ 1 ↔ a ∈ s ∩ mulSupport f
Theorem: Ordinal.enumOrd_def
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [enumOrd_def']
state_before: S : Set Ordinal
o : Ordinal
⊢ enumOrd S o = sInf (S ∩ {b | ∀ (c : Ordinal), c < o → enumOrd S c < b})

tactic: congr
state_before: S : Set Ordinal
o : Ordinal
⊢ sInf (S ∩ Ici (blsub o fun a x => enumOrd S a)) = sInf (S ∩ {b | ∀ (c : Ordinal), c < o → enumOrd S c < b})

tactic: ext
state_before: case e_a.e_a
S : Set Ordinal
o : Ordinal
⊢ Ici (blsub o fun a x => enumOrd S a) = {b | ∀ (c : Ordinal), c < o → enumOrd S c < b}

tactic: exact ⟨fun h a hao => (lt_blsub.{u, u} _ _ hao).trans_le h, blsub_le⟩
state_before: case e_a.e_a.h
S : Set Ordinal
o x✝ : Ordinal
⊢ x✝ ∈ Ici (blsub o fun a x => enumOrd S a) ↔ x✝ ∈ {b | ∀ (c : Ordinal), c < o → enumOrd S c < b}
Theorem: Basis.finTwoProd_zero
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.finTwoProd, LinearEquiv.finTwoArrow]
state_before: ι : Type ?u.1076425
ι' : Type ?u.1076428
R✝ : Type ?u.1076431
R₂ : Type ?u.1076434
K : Type ?u.1076437
M : Type ?u.1076440
M' : Type ?u.1076443
M'' : Type ?u.1076446
V : Type u
V' : Type ?u.1076451
v : ι → M
inst✝⁹ : Ring R✝
inst✝⁸ : CommRing R₂
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M''
inst✝⁴ : Module R✝ M
inst✝³ : Module R₂ M
inst✝² : Module R✝ M'
inst✝¹ : Module R✝ M''
c d : R✝
x y : M
b : Basis ι R✝ M
R : Type u_1
inst✝ : Semiring R
⊢ ↑(Basis.finTwoProd R) 0 = (1, 0)
Theorem: Rack.self_act_invAct_eq
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← left_cancel (x ◃ x)]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y

tactic: rw [right_inv]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ (x ◃ x) ◃ (x ◃ x) ◃⁻¹ y = (x ◃ x) ◃ x ◃⁻¹ y

tactic: rw [self_act_act_eq]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = (x ◃ x) ◃ x ◃⁻¹ y

tactic: rw [right_inv]
state_before: R : Type u_1
inst✝ : Rack R
x y : R
⊢ y = x ◃ x ◃⁻¹ y
Theorem: commutative_ring_iff_abelian_lie_ring
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: have h₂ : IsLieAbelian A ↔ ∀ a b : A, ⁅a, b⁆ = 0 := ⟨fun h => h.1, fun h => ⟨h⟩⟩
state_before: A : Type v
inst✝ : Ring A
h₁ : (IsCommutative A fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
⊢ (IsCommutative A fun x x_1 => x * x_1) ↔ IsLieAbelian A

tactic: simp only [h₁, h₂, LieRing.of_associative_ring_bracket, sub_eq_zero]
state_before: A : Type v
inst✝ : Ring A
h₁ : (IsCommutative A fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
h₂ : IsLieAbelian A ↔ ∀ (a b : A), ⁅a, b⁆ = 0
⊢ (IsCommutative A fun x x_1 => x * x_1) ↔ IsLieAbelian A
Theorem: AffineMap.homothety_zero
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: ext p
state_before: R : Type ?u.815526
k : Type u_3
V1 : Type u_1
P1 : Type u_2
V2 : Type ?u.815538
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c : P1
⊢ homothety c 0 = const k P1 c

tactic: simp [homothety_apply]
state_before: case h
R : Type ?u.815526
k : Type u_3
V1 : Type u_1
P1 : Type u_2
V2 : Type ?u.815538
inst✝⁵ : CommRing k
inst✝⁴ : AddCommGroup V1
inst✝³ : AffineSpace V1 P1
inst✝² : AddCommGroup V2
inst✝¹ : Module k V1
inst✝ : Module k V2
c p : P1
⊢ ↑(homothety c 0) p = ↑(const k P1 c) p
Theorem: Set.prod_union
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12021
δ : Type ?u.12024
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂

tactic: simp [and_or_left]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.12021
δ : Type ?u.12024
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ (t₁ ∪ t₂) ↔ (x, y) ∈ s ×ˢ t₁ ∪ s ×ˢ t₂
Theorem: hammingNorm_comp
File: Mathlib/InformationTheory/Hamming.lean

tactic: simpa only [← hammingDist_zero_right, hf₂] using hammingDist_comp f hf₁ (y := fun _ ↦ 0)
state_before: α : Type ?u.28287
ι : Type u_3
β : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : (i : ι) → DecidableEq (β i)
γ : ι → Type u_1
inst✝² : (i : ι) → DecidableEq (γ i)
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → Zero (γ i)
f : (i : ι) → γ i → β i
x : (i : ι) → γ i
hf₁ : ∀ (i : ι), Injective (f i)
hf₂ : ∀ (i : ι), f i 0 = 0
⊢ (hammingNorm fun i => f i (x i)) = hammingNorm x
Theorem: UniformInducing.cauchy_map_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: simp only [Cauchy, map_neBot_iff, prod_map_map_eq, map_le_iff_le_comap, ← hf.comap_uniformity]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformInducing f
F : Filter α
⊢ Cauchy (map f F) ↔ Cauchy F
Theorem: OrthonormalBasis.repr_injective
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: cases f
state_before: ι : Type u_1
ι' : Type ?u.731886
𝕜 : Type u_2
inst✝⁹ : IsROrC 𝕜
E : Type u_3
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.731915
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.731933
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.731953
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
f g : OrthonormalBasis ι 𝕜 E
h : f.repr = g.repr
⊢ f = g

tactic: cases g
state_before: case ofRepr
ι : Type u_1
ι' : Type ?u.731886
𝕜 : Type u_2
inst✝⁹ : IsROrC 𝕜
E : Type u_3
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.731915
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.731933
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.731953
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
g : OrthonormalBasis ι 𝕜 E
repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝ }.repr = g.repr
⊢ { repr := repr✝ } = g

tactic: congr
state_before: case ofRepr.ofRepr
ι : Type u_1
ι' : Type ?u.731886
𝕜 : Type u_2
inst✝⁹ : IsROrC 𝕜
E : Type u_3
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.731915
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.731933
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.731953
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
repr✝¹ repr✝ : E ≃ₗᵢ[𝕜] EuclideanSpace 𝕜 ι
h : { repr := repr✝¹ }.repr = { repr := repr✝ }.repr
⊢ { repr := repr✝¹ } = { repr := repr✝ }
Theorem: Filter.iInf_le_liminf
File: Mathlib/Order/LiminfLimsup.lean

tactic: isBoundedDefault
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.105503
ι : Type ?u.105506
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ IsCoboundedUnder (fun x x_1 => x ≥ x_1) f u
Theorem: eq_compl_comm
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [eq_comm, compl_eq_iff_isCompl, eq_compl_iff_isCompl]
state_before: α : Type u
β : Type ?u.54408
w x y z : α
inst✝ : BooleanAlgebra α
⊢ x = yᶜ ↔ y = xᶜ
Theorem: Pell.xy_succ_succ
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: have := pellZd_succ_succ a1 n
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)

tactic: unfold pellZd at this
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this : pellZd a1 (n + 2) + pellZd a1 n = ↑(2 * a) * pellZd a1 (n + 1)
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)

tactic: erw [Zsqrtd.smul_val (2 * a : ℕ)] at this
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    ↑(2 * a) * { re := ↑(xn a1 (n + 1)), im := ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)

tactic: injection this with h₁ h₂
state_before: a : ℕ
a1 : 1 < a
n : ℕ
this :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) } + { re := ↑(xn a1 n), im := ↑(yn a1 n) } =
    { re := ↑(2 * a) * ↑(xn a1 (n + 1)), im := ↑(2 * a) * ↑(yn a1 (n + 1)) }
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)

tactic: constructor <;> apply Int.ofNat.inj <;> [simpa using h₁; simpa using h₂]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
h₁ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.re + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.re =
    ↑(2 * a) * ↑(xn a1 (n + 1))
h₂ :
  { re := ↑(xn a1 (n + 2)), im := ↑(yn a1 (n + 2)) }.im + { re := ↑(xn a1 n), im := ↑(yn a1 n) }.im =
    ↑(2 * a) * ↑(yn a1 (n + 1))
⊢ xn a1 (n + 2) + xn a1 n = 2 * a * xn a1 (n + 1) ∧ yn a1 (n + 2) + yn a1 n = 2 * a * yn a1 (n + 1)
Theorem: Multiset.Pi.cons_injective
File: Mathlib/Data/Multiset/Pi.lean

tactic: rw [Pi.cons_ne this ne.symm]
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
a : α
b : δ a
s : Multiset α
hs : ¬a ∈ s
f₁ f₂ : (a : α) → a ∈ s → δ a
eq : cons s a b f₁ = cons s a b f₂
a' : α
h' : a' ∈ s
ne : a ≠ a'
this : a' ∈ a ::ₘ s
⊢ f₁ a' h' = cons s a b f₁ a' this

tactic: rw [eq]
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
a : α
b : δ a
s : Multiset α
hs : ¬a ∈ s
f₁ f₂ : (a : α) → a ∈ s → δ a
eq : cons s a b f₁ = cons s a b f₂
a' : α
h' : a' ∈ s
ne : a ≠ a'
this : a' ∈ a ::ₘ s
⊢ cons s a b f₁ a' this = cons s a b f₂ a' this

tactic: rw [Pi.cons_ne this ne.symm]
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
a : α
b : δ a
s : Multiset α
hs : ¬a ∈ s
f₁ f₂ : (a : α) → a ∈ s → δ a
eq : cons s a b f₁ = cons s a b f₂
a' : α
h' : a' ∈ s
ne : a ≠ a'
this : a' ∈ a ::ₘ s
⊢ cons s a b f₂ a' this = f₂ a' h'
Theorem: LinearMap.map_comp_lTensor
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: simp only [lTensor, rTensor, ← map_comp, id_comp, comp_id]
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
R' : Type ?u.1285748
inst✝¹³ : Monoid R'
R'' : Type ?u.1285754
inst✝¹² : Semiring R''
M : Type u_2
N : Type u_4
P : Type u_3
Q : Type u_5
S : Type u_6
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid N
inst✝⁹ : AddCommMonoid P
inst✝⁸ : AddCommMonoid Q
inst✝⁷ : AddCommMonoid S
inst✝⁶ : Module R M
inst✝⁵ : Module R N
inst✝⁴ : Module R P
inst✝³ : Module R Q
inst✝² : Module R S
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g✝ : P →ₗ[R] Q
f✝ : N →ₗ[R] P
f : M →ₗ[R] P
g : N →ₗ[R] Q
g' : S →ₗ[R] N
⊢ comp (map f g) (lTensor M g') = map f (comp g g')
Theorem: Polynomial.trinomial_trailingCoeff
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: rw [trailingCoeff, trinomial_natTrailingDegree hkm hmn hu, trinomial_trailing_coeff' hkm hmn]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
hu : u ≠ 0
⊢ trailingCoeff (trinomial k m n u v w) = u
Theorem: Int.lt_add_of_sub_left_lt
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_lt_add_right h b
state_before: a b c : Int
h : a - b < c
⊢ a < b + c

tactic: rwa [Int.sub_add_cancel, Int.add_comm] at h
state_before: a b c : Int
h✝ : a - b < c
h : a - b + b < c + b
⊢ a < b + c
Theorem: Ordinal.div_eq_zero_of_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← Ordinal.le_zero, div_le <| Ordinal.pos_iff_ne_zero.1 <| (Ordinal.zero_le _).trans_lt h]
state_before: α : Type ?u.243145
β : Type ?u.243148
γ : Type ?u.243151
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : a < b
⊢ a / b = 0

tactic: simpa only [succ_zero, mul_one] using h
state_before: α : Type ?u.243145
β : Type ?u.243148
γ : Type ?u.243151
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
h : a < b
⊢ a < b * succ 0