tasksource/leandojo huggingface dataset:
Theorem: Eq.congr_right
File: Mathlib/Logic/Basic.lean

tactic: rw [h]
state_before: α : Sort u_1
x y z : α
h : x = y
⊢ z = x ↔ z = y
Theorem: toIocMod_add_right'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIocMod_add_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (a + p) b = toIocMod hp a b + p
Theorem: AddSubgroup.fg_iff_mul_fg
File: Mathlib/GroupTheory/Finiteness.lean

tactic: rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
state_before: M : Type ?u.72408
N : Type ?u.72411
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type ?u.72420
H : Type u_1
inst✝¹ : Group G
inst✝ : AddGroup H
P : AddSubgroup H
⊢ FG P ↔ Subgroup.FG (↑toSubgroup P)

tactic: exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
state_before: M : Type ?u.72408
N : Type ?u.72411
inst✝³ : Monoid M
inst✝² : AddMonoid N
G : Type ?u.72420
H : Type u_1
inst✝¹ : Group G
inst✝ : AddGroup H
P : AddSubgroup H
⊢ AddSubmonoid.FG P.toAddSubmonoid ↔ Submonoid.FG (↑toSubgroup P).toSubmonoid
Theorem: SemiconjBy.add_right
File: Mathlib/Algebra/Ring/Semiconj.lean

tactic: simp only [SemiconjBy, left_distrib, right_distrib, h.eq, h'.eq]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Distrib R
a x y x' y' : R
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x + x') (y + y')
Theorem: List.foldr_ext
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl ih
state_before: ι : Type ?u.229572
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → β
b : β
l : List α
H : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b
⊢ foldr f b l = foldr g b l

tactic: simp only [mem_cons, or_imp, forall_and, forall_eq] at H
state_before: case cons
ι : Type ?u.229572
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → β
b : β
l : List α
H✝ : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : ∀ (a : α), a ∈ hd :: tl → ∀ (b : β), f a b = g a b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)

tactic: simp only [foldr, ih H.2, H.1]
state_before: case cons
ι : Type ?u.229572
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → β
b : β
l : List α
H✝ : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b
hd : α
tl : List α
ih : (∀ (a : α), a ∈ tl → ∀ (b : β), f a b = g a b) → foldr f b tl = foldr g b tl
H : (∀ (b : β), f hd b = g hd b) ∧ ∀ (x : α), x ∈ tl → ∀ (b : β), f x b = g x b
⊢ foldr f b (hd :: tl) = foldr g b (hd :: tl)

tactic: rfl
state_before: case nil
ι : Type ?u.229572
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f g : α → β → β
b : β
l : List α
H✝ : ∀ (a : α), a ∈ l → ∀ (b : β), f a b = g a b
H : ∀ (a : α), a ∈ [] → ∀ (b : β), f a b = g a b
⊢ foldr f b [] = foldr g b []
Theorem: smul_balancedCore_subset
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

tactic: rintro x ⟨y, hy, rfl⟩
state_before: 𝕜 : Type u_2
E : Type u_1
ι : Type ?u.2242
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s✝ t : Set E
x : E
s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
⊢ a • balancedCore 𝕜 s ⊆ balancedCore 𝕜 s

tactic: rw [mem_balancedCore_iff] at hy
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.2242
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s✝ t : Set E
x : E
s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
y : E
hy : y ∈ balancedCore 𝕜 s
⊢ (fun x => a • x) y ∈ balancedCore 𝕜 s

tactic: rcases hy with ⟨t, ht1, ht2, hy⟩
state_before: case intro.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.2242
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s✝ t : Set E
x : E
s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
y : E
hy : ∃ t, Balanced 𝕜 t ∧ t ⊆ s ∧ y ∈ t
⊢ (fun x => a • x) y ∈ balancedCore 𝕜 s

tactic: exact ⟨t, ⟨ht1, ht2⟩, ht1 a ha (smul_mem_smul_set hy)⟩
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_2
E : Type u_1
ι : Type ?u.2242
inst✝¹ : SeminormedRing 𝕜
inst✝ : SMul 𝕜 E
s✝ t✝ : Set E
x : E
s : Set E
a : 𝕜
ha : ‖a‖ ≤ 1
y : E
t : Set E
ht1 : Balanced 𝕜 t
ht2 : t ⊆ s
hy : y ∈ t
⊢ (fun x => a • x) y ∈ balancedCore 𝕜 s
Theorem: dvd_of_one_le_padicValNat
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: by_contra h
state_before: p n : ℕ
hp : 1 ≤ padicValNat p n
⊢ p ∣ n

tactic: rw [padicValNat.eq_zero_of_not_dvd h] at hp
state_before: p n : ℕ
hp : 1 ≤ padicValNat p n
h : ¬p ∣ n
⊢ False

tactic: exact lt_irrefl 0 (lt_of_lt_of_le zero_lt_one hp)
state_before: p n : ℕ
hp : 1 ≤ 0
h : ¬p ∣ n
⊢ False
Theorem: zero_lt_bit0
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: rw [bit0, ← two_mul, zero_lt_mul_left (zero_lt_two : 0 < (2 : α))]
state_before: α : Type u
β : Type ?u.148469
inst✝ : LinearOrderedSemiring α
a b c d : α
⊢ 0 < bit0 a ↔ 0 < a
Theorem: vectorSpan_range_eq_span_range_vsub_left
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [vectorSpan_eq_span_vsub_set_left k (Set.mem_range_self i0), ← Set.range_comp]
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ vectorSpan k (range p) = Submodule.span k (range fun i => p i0 -ᵥ p i)

tactic: congr
state_before: k : Type u_2
V : Type u_1
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
i0 : ι
⊢ Submodule.span k (range ((fun x x_1 => x -ᵥ x_1) (p i0) ∘ p)) = Submodule.span k (range fun i => p i0 -ᵥ p i)
Theorem: ENNReal.ofReal_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp_rw [ENNReal.ofReal]
state_before: x p : ℝ
hx_pos : 0 < x
⊢ ENNReal.ofReal x ^ p = ENNReal.ofReal (x ^ p)

tactic: rw [coe_rpow_of_ne_zero, coe_eq_coe, Real.toNNReal_rpow_of_nonneg hx_pos.le]
state_before: x p : ℝ
hx_pos : 0 < x
⊢ ↑(toNNReal x) ^ p = ↑(toNNReal (x ^ p))

tactic: simp [hx_pos]
state_before: case h
x p : ℝ
hx_pos : 0 < x
⊢ toNNReal x ≠ 0
Theorem: Irreducible.squarefree
File: Mathlib/Algebra/Squarefree.lean

tactic: rintro y ⟨z, hz⟩
state_before: R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
⊢ Squarefree x

tactic: rw [mul_assoc] at hz
state_before: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * y * z
⊢ IsUnit y

tactic: rcases h.isUnit_or_isUnit hz with (hu | hu)
state_before: case intro
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
⊢ IsUnit y

tactic: exact hu
state_before: case intro.inl
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
hu : IsUnit y
⊢ IsUnit y

tactic: apply isUnit_of_mul_isUnit_left hu
state_before: case intro.inr
R : Type u_1
inst✝ : CommMonoid R
x : R
h : Irreducible x
y z : R
hz : x = y * (y * z)
hu : IsUnit (y * z)
⊢ IsUnit y
Theorem: Primrec₂.natPair
File: Mathlib/Computability/Primrec.lean

tactic: simp [Primrec₂, Primrec]
state_before: α : Type ?u.63315
β : Type ?u.63318
σ : Type ?u.63321
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
⊢ Primrec₂ Nat.pair

tactic: constructor
state_before: α : Type ?u.63315
β : Type ?u.63318
σ : Type ?u.63321
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
⊢ Nat.Primrec fun n => Nat.succ n
Theorem: FiberPrebundle.continuous_symm_of_mem_pretrivializationAtlas
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: refine' fun z H U h => preimage_nhdsWithin_coinduced' H (le_def.1 (nhds_mono _) U h)
state_before: ι : Type ?u.56599
B : Type u_1
F : Type u_2
X : Type ?u.56608
inst✝³ : TopologicalSpace X
E : B → Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
⊢ ContinuousOn (↑(LocalEquiv.symm e.toLocalEquiv)) e.target

tactic: exact le_iSup₂ (α := TopologicalSpace (TotalSpace E)) e he
state_before: ι : Type ?u.56599
B : Type u_1
F : Type u_2
X : Type ?u.56608
inst✝³ : TopologicalSpace X
E : B → Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : (x : B) → TopologicalSpace (E x)
a : FiberPrebundle F E
e : Pretrivialization F TotalSpace.proj
he : e ∈ a.pretrivializationAtlas
z : B × F
H : z ∈ e.target
U : Set (TotalSpace E)
h : U ∈ 𝓝 (↑(LocalEquiv.symm e.toLocalEquiv) z)
⊢ coinduced (fun x => ↑(LocalEquiv.symm e.toLocalEquiv) ↑x) inferInstance ≤ totalSpaceTopology a
Theorem: MeasureTheory.SimpleFunc.tsum_eapproxDiff
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp_rw [ENNReal.tsum_eq_iSup_nat' (tendsto_add_atTop_nat 1), sum_eapproxDiff,
  iSup_eapprox_apply f hf a]
state_before: α : Type u_1
β : Type ?u.850348
γ : Type ?u.850351
δ : Type ?u.850354
inst✝ : MeasurableSpace α
K : Type ?u.850360
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ (∑' (n : ℕ), ↑(↑(eapproxDiff f n) a)) = f a
Theorem: Multiset.le_dedup_self
File: Mathlib/Data/Multiset/Dedup.lean

tactic: rw [le_dedup, and_iff_right le_rfl]
state_before: α : Type u_1
β : Type ?u.9026
inst✝ : DecidableEq α
s : Multiset α
⊢ s ≤ dedup s ↔ Nodup s
Theorem: mulSupport_comp_inv_smul₀
File: Mathlib/Data/Set/Pointwise/Support.lean

tactic: ext x
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
inst✝ : One γ
c : α
hc : c ≠ 0
f : β → γ
⊢ (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f

tactic: simp only [mem_smul_set_iff_inv_smul_mem₀ hc, mem_mulSupport]
state_before: case h
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
inst✝ : One γ
c : α
hc : c ≠ 0
f : β → γ
x : β
⊢ (x ∈ mulSupport fun x => f (c⁻¹ • x)) ↔ x ∈ c • mulSupport f
Theorem: Submonoid.mem_closure_inv
File: Mathlib/GroupTheory/Submonoid/Pointwise.lean

tactic: rw [closure_inv, mem_inv]
state_before: α : Type ?u.141598
G✝ : Type ?u.141601
M : Type ?u.141604
R : Type ?u.141607
A : Type ?u.141610
inst✝² : Monoid M
inst✝¹ : AddMonoid A
G : Type u_1
inst✝ : Group G
S : Set G
x : G
⊢ x ∈ closure S⁻¹ ↔ x⁻¹ ∈ closure S
Theorem: FreeLieAlgebra.Rel.subLeft
File: Mathlib/Algebra/Lie/Free.lean

tactic: simpa only [sub_eq_add_neg] using h.neg.addLeft a
state_before: R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (a - b) (a - c)
Theorem: finprod_eq_prod_pLift_of_mulSupport_toFinset_subset
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [finprod, dif_pos]
state_before: G : Type ?u.27905
M : Type u_2
N : Type ?u.27911
α : Sort u_1
β : Sort ?u.27917
ι : Sort ?u.27920
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport (f ∘ PLift.down))
s : Finset (PLift α)
hs : Finite.toFinset hf ⊆ s
⊢ (∏ᶠ (i : α), f i) = ∏ i in s, f i.down

tactic: refine' Finset.prod_subset hs fun x _ hxf => _
state_before: G : Type ?u.27905
M : Type u_2
N : Type ?u.27911
α : Sort u_1
β : Sort ?u.27917
ι : Sort ?u.27920
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport (f ∘ PLift.down))
s : Finset (PLift α)
hs : Finite.toFinset hf ⊆ s
⊢ ∏ i in Finite.toFinset ?hc, f i.down = ∏ i in s, f i.down

case hc
G : Type ?u.27905
M : Type u_2
N : Type ?u.27911
α : Sort u_1
β : Sort ?u.27917
ι : Sort ?u.27920
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport (f ∘ PLift.down))
s : Finset (PLift α)
hs : Finite.toFinset hf ⊆ s
⊢ Set.Finite (mulSupport ((fun i => f i) ∘ PLift.down))

tactic: rwa [hf.mem_toFinset, nmem_mulSupport] at hxf
state_before: G : Type ?u.27905
M : Type u_2
N : Type ?u.27911
α : Sort u_1
β : Sort ?u.27917
ι : Sort ?u.27920
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
hf : Set.Finite (mulSupport (f ∘ PLift.down))
s : Finset (PLift α)
hs : Finite.toFinset hf ⊆ s
x : PLift α
x✝ : x ∈ s
hxf : ¬x ∈ Finite.toFinset hf
⊢ f x.down = 1
Theorem: SeparationQuotient.continuousOn_lift₂
File: Mathlib/Topology/Inseparable.lean

tactic: simp_rw [ContinuousOn, (surjective_mk.Prod_map surjective_mk).forall, Prod.forall, Prod.map,
  continuousWithinAt_lift₂]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type ?u.110528
ι : Type ?u.110531
π : ι → Type ?u.110536
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s✝ : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → Y → Z
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
s : Set (SeparationQuotient X × SeparationQuotient Y)
⊢ ContinuousOn (uncurry (lift₂ f hf)) s ↔ ContinuousOn (uncurry f) (Prod.map mk mk ⁻¹' s)

tactic: rfl
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type ?u.110528
ι : Type ?u.110531
π : ι → Type ?u.110536
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s✝ : Set X
f✝ : X → Y
t : Set (SeparationQuotient X)
f : X → Y → Z
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
s : Set (SeparationQuotient X × SeparationQuotient Y)
⊢ (∀ (a : X) (b : Y), (mk a, mk b) ∈ s → ContinuousWithinAt (uncurry f) (Prod.map mk mk ⁻¹' s) (a, b)) ↔
    ∀ (a : X) (b : Y),
      (a, b) ∈ (fun x => (mk x.fst, mk x.snd)) ⁻¹' s →
        ContinuousWithinAt (uncurry f) ((fun x => (mk x.fst, mk x.snd)) ⁻¹' s) (a, b)
Theorem: LinearMap.injective_or_eq_zero
File: Mathlib/RingTheory/SimpleModule.lean

tactic: rw [← ker_eq_bot, ← ker_eq_top]
state_before: R : Type u_1
inst✝⁵ : Ring R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_3
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R M
f : M →ₗ[R] N
⊢ Function.Injective ↑f ∨ f = 0

tactic: apply eq_bot_or_eq_top
state_before: R : Type u_1
inst✝⁵ : Ring R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_3
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R M
f : M →ₗ[R] N
⊢ ker f = ⊥ ∨ ker f = ⊤
Theorem: div_le_one_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [one_mul]
state_before: ι : Type ?u.44686
α : Type u_1
β : Type ?u.44692
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
h : a ≤ b
hb : 0 ≤ b
⊢ a ≤ 1 * b
Theorem: Sum.traverse_eq_map_id
File: Mathlib/Control/Traversable/Instances.lean

tactic: induction x <;> simp! [*, functor_norm] <;> rfl
state_before: σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
x : σ ⊕ α
⊢ Sum.traverse (pure ∘ f) x = pure (f <$> x)
Theorem: MeasureTheory.tsum_measure_le_measure_univ
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_1
β : Type ?u.40097
γ : Type ?u.40100
δ : Type ?u.40103
ι : Type u_2
R : Type ?u.40109
R' : Type ?u.40112
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : Pairwise (Disjoint on s)
⊢ (∑' (i : ι), ↑↑μ (s i)) ≤ ↑↑μ univ

tactic: exact iSup_le fun s =>
  sum_measure_le_measure_univ (fun i _hi => hs i) fun i _hi j _hj hij => H hij
state_before: α : Type u_1
β : Type ?u.40097
γ : Type ?u.40100
δ : Type ?u.40103
ι : Type u_2
R : Type ?u.40109
R' : Type ?u.40112
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
s : ι → Set α
hs : ∀ (i : ι), MeasurableSet (s i)
H : Pairwise (Disjoint on s)
⊢ (⨆ (s_1 : Finset ι), ∑ a in s_1, ↑↑μ (s a)) ≤ ↑↑μ univ
Theorem: isIntegral_of_isScalarTower
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rw [← aeval_def, aeval_map_algebraMap, aeval_def, hpx]
state_before: R : Type u_3
A : Type u_1
B : Type u_2
S : Type ?u.176559
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : CommRing S
inst✝³ : Algebra R A
inst✝² : Algebra R B
f : R →+* S
inst✝¹ : Algebra A B
inst✝ : IsScalarTower R A B
x : B
hx : IsIntegral R x
p : R[X]
hp : Monic p
hpx : eval₂ (algebraMap R B) x p = 0
⊢ eval₂ (algebraMap A B) x (Polynomial.map (algebraMap R A) p) = 0
Theorem: Pell.isPell_pellZd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: let o := isPell_one a1
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ IsPell (pellZd a1 (n + 1))

tactic: simp
state_before: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 (n + 1))

tactic: exact Pell.isPell_mul (isPell_pellZd n) o
state_before: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 n * { re := ↑a, im := 1 })
Theorem: isUnit_ring_inverse
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: cases subsingleton_or_nontrivial M₀
state_before: α : Type ?u.10029
M₀ : Type u_1
G₀ : Type ?u.10035
M₀' : Type ?u.10038
G₀' : Type ?u.10041
F : Type ?u.10044
F' : Type ?u.10047
inst✝ : MonoidWithZero M₀
a : M₀
h : IsUnit (Ring.inverse a)
⊢ IsUnit a

tactic: convert h
state_before: case inl
α : Type ?u.10029
M₀ : Type u_1
G₀ : Type ?u.10035
M₀' : Type ?u.10038
G₀' : Type ?u.10041
F : Type ?u.10044
F' : Type ?u.10047
inst✝ : MonoidWithZero M₀
a : M₀
h : IsUnit (Ring.inverse a)
h✝ : Subsingleton M₀
⊢ IsUnit a

tactic: contrapose h
state_before: case inr
α : Type ?u.10029
M₀ : Type u_1
G₀ : Type ?u.10035
M₀' : Type ?u.10038
G₀' : Type ?u.10041
F : Type ?u.10044
F' : Type ?u.10047
inst✝ : MonoidWithZero M₀
a : M₀
h : IsUnit (Ring.inverse a)
h✝ : Nontrivial M₀
⊢ IsUnit a

tactic: rw [Ring.inverse_non_unit _ h]
state_before: case inr
α : Type ?u.10029
M₀ : Type u_1
G₀ : Type ?u.10035
M₀' : Type ?u.10038
G₀' : Type ?u.10041
F : Type ?u.10044
F' : Type ?u.10047
inst✝ : MonoidWithZero M₀
a : M₀
h✝ : Nontrivial M₀
h : ¬IsUnit a
⊢ ¬IsUnit (Ring.inverse a)

tactic: exact not_isUnit_zero
state_before: case inr
α : Type ?u.10029
M₀ : Type u_1
G₀ : Type ?u.10035
M₀' : Type ?u.10038
G₀' : Type ?u.10041
F : Type ?u.10044
F' : Type ?u.10047
inst✝ : MonoidWithZero M₀
a : M₀
h✝ : Nontrivial M₀
h : ¬IsUnit a
⊢ ¬IsUnit 0
Theorem: NormedAddGroupHom.Equalizer.map_id
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: ext
state_before: V : Type ?u.512065
W : Type ?u.512068
V₁ : Type u_1
V₂ : Type ?u.512074
V₃ : Type ?u.512077
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_2
W₂ : Type ?u.512112
W₃ : Type ?u.512115
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
⊢ map (id V₁) (id W₁) (_ : NormedAddGroupHom.comp (id W₁) f₁ = NormedAddGroupHom.comp (id W₁) f₁)
      (_ : NormedAddGroupHom.comp (id W₁) g₁ = NormedAddGroupHom.comp (id W₁) g₁) =
    id { x // x ∈ equalizer f₁ g₁ }

tactic: rfl
state_before: case H.a
V : Type ?u.512065
W : Type ?u.512068
V₁ : Type u_1
V₂ : Type ?u.512074
V₃ : Type ?u.512077
inst✝⁷ : SeminormedAddCommGroup V
inst✝⁶ : SeminormedAddCommGroup W
inst✝⁵ : SeminormedAddCommGroup V₁
inst✝⁴ : SeminormedAddCommGroup V₂
inst✝³ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V W
W₁ : Type u_2
W₂ : Type ?u.512112
W₃ : Type ?u.512115
inst✝² : SeminormedAddCommGroup W₁
inst✝¹ : SeminormedAddCommGroup W₂
inst✝ : SeminormedAddCommGroup W₃
g : NormedAddGroupHom V W
f₁ g₁ : NormedAddGroupHom V₁ W₁
f₂ g₂ : NormedAddGroupHom V₂ W₂
f₃ g₃ : NormedAddGroupHom V₃ W₃
φ : NormedAddGroupHom V₁ V₂
ψ : NormedAddGroupHom W₁ W₂
φ' : NormedAddGroupHom V₂ V₃
ψ' : NormedAddGroupHom W₂ W₃
x✝ : { x // x ∈ equalizer f₁ g₁ }
⊢ ↑(↑(map (id V₁) (id W₁) (_ : NormedAddGroupHom.comp (id W₁) f₁ = NormedAddGroupHom.comp (id W₁) f₁)
            (_ : NormedAddGroupHom.comp (id W₁) g₁ = NormedAddGroupHom.comp (id W₁) g₁))
        x✝) =
    ↑(↑(id { x // x ∈ equalizer f₁ g₁ }) x✝)
Theorem: Matrix.map_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.329269
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.329283
n' : o → Type ?u.329288
R : Type ?u.329291
S : Type ?u.329294
α : Type v
β : Type w
γ : Type ?u.329301
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype n
L : Matrix m n α
M : Matrix n o α
inst✝ : NonAssocSemiring β
f : α →+* β
⊢ map (L ⬝ M) ↑f = map L ↑f ⬝ map M ↑f

tactic: simp [mul_apply, map_sum]
state_before: case a.h
l : Type ?u.329269
m : Type u_2
n : Type u_1
o : Type u_3
m' : o → Type ?u.329283
n' : o → Type ?u.329288
R : Type ?u.329291
S : Type ?u.329294
α : Type v
β : Type w
γ : Type ?u.329301
inst✝² : NonAssocSemiring α
inst✝¹ : Fintype n
L : Matrix m n α
M : Matrix n o α
inst✝ : NonAssocSemiring β
f : α →+* β
i✝ : m
x✝ : o
⊢ map (L ⬝ M) (↑f) i✝ x✝ = (map L ↑f ⬝ map M ↑f) i✝ x✝
Theorem: div_sub_same
File: Mathlib/Algebra/Field/Basic.lean

tactic: simpa only [← @div_self _ _ b h] using (div_sub_div_same a b b).symm
state_before: α : Type ?u.40731
β : Type ?u.40734
K : Type u_1
inst✝ : DivisionRing K
a✝ b✝ c d a b : K
h : b ≠ 0
⊢ (a - b) / b = a / b - 1
Theorem: ENNReal.lt_ofReal_iff_toReal_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: lift a to ℝ≥0 using ha
state_before: α : Type ?u.813310
β : Type ?u.813313
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ
ha : a ≠ ⊤
⊢ a < ENNReal.ofReal b ↔ ENNReal.toReal a < b

tactic: simpa [ENNReal.ofReal, ENNReal.toReal] using Real.lt_toNNReal_iff_coe_lt
state_before: case intro
α : Type ?u.813310
β : Type ?u.813313
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
b : ℝ
a : ℝ≥0
⊢ ↑a < ENNReal.ofReal b ↔ ENNReal.toReal ↑a < b
Theorem: Order.pred_le_iff_eq_or_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: by_cases ha : IsMin a
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b

tactic: rw [ha.pred_eq, or_iff_right_of_imp ge_of_eq]
state_before: case pos
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b

tactic: rw [← pred_lt_iff_of_not_isMin ha, le_iff_eq_or_lt, eq_comm]
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
ha : ¬IsMin a
⊢ pred a ≤ b ↔ b = pred a ∨ a ≤ b
Theorem: Rat.sqrt_eq
File: Mathlib/Data/Rat/Sqrt.lean

tactic: rw [sqrt, mul_self_num, mul_self_den, Int.sqrt_eq, Nat.sqrt_eq, abs_def, divInt_ofNat]
state_before: q : ℚ
⊢ sqrt (q * q) = abs q
Theorem: Ordinal.cof_bsup_le_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← bsup_eq_blsub_iff_lt_bsup.{u, v}] at H
state_before: α : Type ?u.40854
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
H : ∀ (i : Ordinal) (h : i < o), f i h < bsup o f
⊢ cof (bsup o f) ≤ Cardinal.lift (card o)

tactic: rw [H]
state_before: α : Type ?u.40854
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
H : (bsup o fun i h => f i h) = blsub o fun i h => f i h
⊢ cof (bsup o f) ≤ Cardinal.lift (card o)

tactic: exact cof_blsub_le_lift.{u, v} f
state_before: α : Type ?u.40854
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
H : (bsup o fun i h => f i h) = blsub o fun i h => f i h
⊢ cof (blsub o fun i h => f i h) ≤ Cardinal.lift (card o)
Theorem: EuclideanGeometry.sin_angle_mul_dist_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
⊢ Real.sin (∠ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂

tactic: rw [angle, dist_eq_norm_vsub V p₁ p₂, dist_eq_norm_vsub V p₁ p₃, ← vsub_add_vsub_cancel p₁ p₂ p₃,
  add_comm, sin_angle_add_mul_norm_of_inner_eq_zero h]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
⊢ Real.sin (∠ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂