tasksource/leandojo huggingface dataset:
Theorem: DirectSum.linearEquivFunOnFintype_symm_coe
File: Mathlib/Algebra/DirectSum/Module.lean

tactic: simp [linearEquivFunOnFintype]
state_before: R : Type u
inst✝⁵ : Semiring R
ι : Type v
dec_ι : DecidableEq ι
M : ι → Type w
inst✝⁴ : (i : ι) → AddCommMonoid (M i)
inst✝³ : (i : ι) → Module R (M i)
N : Type u₁
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
φ : (i : ι) → M i →ₗ[R] N
ψ ψ' : (⨁ (i : ι), M i) →ₗ[R] N
inst✝ : Fintype ι
f : ⨁ (i : ι), M i
⊢ ↑(LinearEquiv.symm (linearEquivFunOnFintype R ι M)) ↑f = f
Theorem: Metric.preimage_smul_ball
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [preimage_smul, smul_ball]
state_before: M : Type u
G : Type v
X : Type w
inst✝³ : PseudoMetricSpace X
inst✝² : Group G
inst✝¹ : MulAction G X
inst✝ : IsometricSMul G X
c : G
x : X
r : ℝ
⊢ (fun x x_1 => x • x_1) c ⁻¹' ball x r = ball (c⁻¹ • x) r
Theorem: List.Nat.map_swap_antidiagonal
File: Mathlib/Data/List/NatAntidiagonal.lean

tactic: rw [antidiagonal, map_map, ← List.map_reverse, range_eq_range', reverse_range', ←
  range_eq_range', map_map]
state_before: n : ℕ
⊢ map Prod.swap (antidiagonal n) = reverse (antidiagonal n)

tactic: apply map_congr
state_before: n : ℕ
⊢ map (Prod.swap ∘ fun i => (i, n - i)) (range (n + 1)) =
    map ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) (range (n + 1))

tactic: simp (config := { contextual := true }) [Nat.sub_sub_self, lt_succ_iff]
state_before: case a
n : ℕ
⊢ ∀ (x : ℕ),
    x ∈ range (n + 1) → (Prod.swap ∘ fun i => (i, n - i)) x = ((fun i => (i, n - i)) ∘ fun x => 0 + (n + 1) - 1 - x) x
Theorem: upperClosure_image
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← f.symm_symm, ← UpperSet.symm_map, f.symm_symm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.131603
ι : Sort ?u.131606
κ : ι → Sort ?u.131611
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
f : α ≃o β
⊢ upperClosure (↑f '' s) = ↑(UpperSet.map f) (upperClosure s)

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.131603
ι : Sort ?u.131606
κ : ι → Sort ?u.131611
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
f : α ≃o β
⊢ upperClosure (↑f '' s) = ↑(OrderIso.symm (UpperSet.map (OrderIso.symm f))) (upperClosure s)

tactic: simp [-UpperSet.symm_map, UpperSet.map, OrderIso.symm, ← f.le_symm_apply]
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type ?u.131603
ι : Sort ?u.131606
κ : ι → Sort ?u.131611
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
f : α ≃o β
x✝ : β
⊢ x✝ ∈ ↑(upperClosure (↑f '' s)) ↔ x✝ ∈ ↑(↑(OrderIso.symm (UpperSet.map (OrderIso.symm f))) (upperClosure s))
Theorem: Eq.sameCycle
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [h]
state_before: ι : Type ?u.30657
α : Type u_1
β : Type ?u.30663
f✝ g : Perm α
p : α → Prop
x y z : α
h : x = y
f : Perm α
⊢ SameCycle f x y
Theorem: Set.insert_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.16026
δ : Type ?u.16029
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t

tactic: simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.16026
δ : Type ?u.16029
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ insert a s ×ˢ t ↔ (x, y) ∈ Prod.mk a '' t ∪ s ×ˢ t
Theorem: ZMod.neg_one_pow_div_two_of_three_mod_four
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

tactic: rw [← χ₄_eq_neg_one_pow (Nat.odd_of_mod_four_eq_three hn), ← nat_cast_mod, hn]
state_before: n : ℕ
hn : n % 4 = 3
⊢ (-1) ^ (n / 2) = -1

tactic: rfl
state_before: n : ℕ
hn : n % 4 = 3
⊢ ↑χ₄ ↑3 = -1
Theorem: Filter.map_inf
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' map_inf_le.antisymm _
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.281757
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
⊢ map m (f ⊓ g) = map m f ⊓ map m g

tactic: rintro t ⟨s₁, hs₁, s₂, hs₂, ht : m ⁻¹' t = s₁ ∩ s₂⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.281757
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
⊢ map m f ⊓ map m g ≤ map m (f ⊓ g)

tactic: refine' mem_inf_of_inter (image_mem_map hs₁) (image_mem_map hs₂) _
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.281757
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ t ∈ map m f ⊓ map m g

tactic: rw [← image_inter h, image_subset_iff, ht]
state_before: case intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.281757
ι : Sort x
f g : Filter α
m : α → β
h : Injective m
t : Set β
s₁ : Set α
hs₁ : s₁ ∈ f
s₂ : Set α
hs₂ : s₂ ∈ g
ht : m ⁻¹' t = s₁ ∩ s₂
⊢ m '' s₁ ∩ m '' s₂ ⊆ t
Theorem: Basis.equivFun_symm_stdBasis
File: Mathlib/LinearAlgebra/FinsuppVectorSpace.lean

tactic: simp
state_before: R : Type u_2
M : Type u_3
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
b : Basis n R M
i : n
⊢ ↑(LinearEquiv.symm (equivFun b)) (↑(stdBasis R (fun x => R) i) 1) = ↑b i
Theorem: Finset.product_inter
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.75579
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ s ×ˢ (t ∩ t') = s ×ˢ t ∩ s ×ˢ t'

tactic: simp only [← and_and_left, mem_inter, mem_product]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type ?u.75579
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ (t ∩ t') ↔ (x, y) ∈ s ×ˢ t ∩ s ×ˢ t'
Theorem: Sum.Ioo_inr_inl
File: Mathlib/Data/Sum/Interval.lean

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a₁ a₂ : α
b₁ b₂ : β
a b : α ⊕ β
⊢ Ioo (inr b₁) (inl a₂) = ∅
Theorem: List.Chain.pairwise
File: Mathlib/Data/List/Chain.lean

tactic: simp only [mem_cons, forall_eq_or_imp, h, true_and_iff]
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ : α
inst✝ : IsTrans α R
a b : α
l : List α
h : R a b
hb : Chain R b l
⊢ ∀ (a' : α), a' ∈ b :: l → R a a'

tactic: exact fun c hc => _root_.trans h (rel_of_pairwise_cons hb.pairwise hc)
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ : α
inst✝ : IsTrans α R
a b : α
l : List α
h : R a b
hb : Chain R b l
⊢ ∀ (a_1 : α), a_1 ∈ l → R a a_1
Theorem: calc_norm_le_one
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [hz.1]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖↑(Polynomial.eval z F)‖ / ‖↑(Polynomial.eval z (↑Polynomial.derivative F))‖ =
    ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: gcongr
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ≤
    ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n /
      ‖Polynomial.eval a (↑Polynomial.derivative F)‖

tactic: apply hz.2
state_before: case h
p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
n : ℕ
z : ℤ_[p]
hz : ih_gen n z
⊢ ‖Polynomial.eval z F‖ ≤ ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n
Theorem: RatFunc.num_div_dvd'
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simpa using num_div_dvd p hq
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ ↑C (leadingCoeff (q / gcd p q))⁻¹ * (p / gcd p q) ∣ p
Theorem: List.zipWith_comm_of_comm
File: Mathlib/Data/List/Zip.lean

tactic: rw [zipWith_comm]
state_before: α : Type u
β : Type u_1
γ : Type ?u.89441
δ : Type ?u.89444
ε : Type ?u.89447
f : α → α → β
comm : ∀ (x y : α), f x y = f y x
l l' : List α
⊢ zipWith f l l' = zipWith f l' l

tactic: simp only [comm]
state_before: α : Type u
β : Type u_1
γ : Type ?u.89441
δ : Type ?u.89444
ε : Type ?u.89447
f : α → α → β
comm : ∀ (x y : α), f x y = f y x
l l' : List α
⊢ zipWith (fun b a => f a b) l' l = zipWith f l' l
Theorem: Nat.mul_le_mul_of_nonneg_right
File: Std/Data/Nat/Lemmas.lean

tactic: if hba : b ≤ a then simp [Nat.le_antisymm hba h₁] else
if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else
exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
⊢ a * c ≤ b * c

tactic: simp [Nat.le_antisymm hba h₁]
state_before: a b c : Nat
h₁ : a ≤ b
hba : b ≤ a
⊢ a * c ≤ b * c

tactic: if hc0 : c ≤ 0 then simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero] else
exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
⊢ a * c ≤ b * c

tactic: simp [Nat.le_antisymm hc0 (zero_le c), Nat.mul_zero]
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
hc0 : c ≤ 0
⊢ a * c ≤ b * c

tactic: exact Nat.le_of_lt (Nat.mul_lt_mul_of_pos_right (Nat.not_le.1 hba) (Nat.not_le.1 hc0))
state_before: a b c : Nat
h₁ : a ≤ b
hba : ¬b ≤ a
hc0 : ¬c ≤ 0
⊢ a * c ≤ b * c
Theorem: Set.OrdConnected.image_real_toNNReal
File: Mathlib/Data/Real/NNReal.lean

tactic: refine' ⟨ball_image_iff.2 fun x hx => ball_image_iff.2 fun y hy z hz => _⟩
state_before: s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
⊢ OrdConnected (toNNReal '' s)

tactic: cases' le_total y 0 with hy₀ hy₀
state_before: s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc (toNNReal x) (toNNReal y)
⊢ z ∈ toNNReal '' s

tactic: rw [mem_Icc, Real.toNNReal_of_nonpos hy₀, nonpos_iff_eq_zero] at hz
state_before: case inl
s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc (toNNReal x) (toNNReal y)
hy₀ : y ≤ 0
⊢ z ∈ toNNReal '' s

tactic: exact ⟨y, hy, (toNNReal_of_nonpos hy₀).trans hz.2.symm⟩
state_before: case inl
s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : toNNReal x ≤ z ∧ z = 0
hy₀ : y ≤ 0
⊢ z ∈ toNNReal '' s

tactic: lift y to ℝ≥0 using hy₀
state_before: case inr
s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
y : ℝ
hy : y ∈ s
z : ℝ≥0
hz : z ∈ Icc (toNNReal x) (toNNReal y)
hy₀ : 0 ≤ y
⊢ z ∈ toNNReal '' s

tactic: rw [toNNReal_coe] at hz
state_before: case inr.intro
s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
z y : ℝ≥0
hy : ↑y ∈ s
hz : z ∈ Icc (toNNReal x) (toNNReal ↑y)
⊢ z ∈ toNNReal '' s

tactic: exact ⟨z, h.out hx hy ⟨toNNReal_le_iff_le_coe.1 hz.1, hz.2⟩, toNNReal_coe⟩
state_before: case inr.intro
s : Set ℝ
t : Set ℝ≥0
h : OrdConnected s
x : ℝ
hx : x ∈ s
z y : ℝ≥0
hy : ↑y ∈ s
hz : z ∈ Icc (toNNReal x) y
⊢ z ∈ toNNReal '' s
Theorem: LinearMap.coe_det
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: ext
state_before: R : Type ?u.298780
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.299371
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.299913
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.300889
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
⊢ ↑LinearMap.det =
    ↑(if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then
        detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose H } A M))))
      else 1)

tactic: rw [LinearMap.det_def]
state_before: case h
R : Type ?u.298780
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.299371
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.299913
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.300889
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
x✝ : M →ₗ[A] M
⊢ ↑LinearMap.det x✝ =
    ↑(if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then
          detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose H } A M))))
        else 1)
      x✝

tactic: split_ifs
state_before: case h
R : Type ?u.298780
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.299371
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.299913
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.300889
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
x✝ : M →ₗ[A] M
⊢ ↑(if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then
          detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose H } A M))))
        else 1)
      x✝ =
    ↑(if H : ∃ s, Nonempty (Basis { x // x ∈ s } A M) then
          detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose H } A M))))
        else 1)
      x✝

tactic: rfl
state_before: case h.inr
R : Type ?u.298780
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.299371
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.299913
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.300889
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
x✝ : M →ₗ[A] M
h✝ : ¬∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ ↑1 x✝ = ↑1 x✝

tactic: congr
state_before: case h.inl
R : Type ?u.298780
inst✝¹⁰ : CommRing R
M : Type u_1
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
M' : Type ?u.299371
inst✝⁷ : AddCommGroup M'
inst✝⁶ : Module R M'
ι : Type ?u.299913
inst✝⁵ : DecidableEq ι
inst✝⁴ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝³ : CommRing A
inst✝² : Module A M
κ : Type ?u.300889
inst✝¹ : Fintype κ
inst✝ : DecidableEq M
x✝ : M →ₗ[A] M
h✝ : ∃ s, Nonempty (Basis { x // x ∈ s } A M)
⊢ ↑(detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose h✝ } A M))))) x✝ =
    ↑(detAux (Trunc.mk (Nonempty.some (_ : Nonempty (Basis { x // x ∈ Exists.choose h✝ } A M))))) x✝
Theorem: Finset.mem_falling
File: Mathlib/Combinatorics/SetFamily/LYM.lean

tactic: simp_rw [falling, mem_sup, mem_powersetLen]
state_before: 𝕜 : Type ?u.13760
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ s ∈ falling k 𝒜 ↔ (∃ t, t ∈ 𝒜 ∧ s ⊆ t) ∧ card s = k

tactic: aesop
state_before: 𝕜 : Type ?u.13760
α : Type u_1
inst✝¹ : LinearOrderedField 𝕜
inst✝ : DecidableEq α
k : ℕ
𝒜 : Finset (Finset α)
s : Finset α
⊢ (∃ v, v ∈ 𝒜 ∧ s ⊆ v ∧ card s = k) ↔ (∃ t, t ∈ 𝒜 ∧ s ⊆ t) ∧ card s = k
Theorem: Polynomial.IsPrimitive.primPart_eq
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: rw [← one_mul p.primPart, ← C_1, ← hp.content_eq_one, ← p.eq_C_content_mul_primPart]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp : IsPrimitive p
⊢ primPart p = p
Theorem: Qpf.Wrepr_equiv
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: induction' x with a f ih
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
x : PFunctor.W (P F)
⊢ Wequiv (Wrepr x) x

tactic: apply Wequiv.trans
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ Wequiv (Wrepr (WType.mk a f)) (WType.mk a f)

tactic: apply Wequiv.ind
state_before: case mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ Wequiv (PFunctor.W.mk (Wrepr <$> { fst := a, snd := f })) (WType.mk a f)

tactic: exact ih
state_before: case mk.a.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ ∀ (x : PFunctor.B (P F) a), Wequiv ((Wrepr ∘ f) x) (f x)

tactic: change Wequiv (Wrepr ⟨a, f⟩) (PFunctor.W.mk (Wrepr <$> ⟨a, f⟩))
state_before: case mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ Wequiv (Wrepr (WType.mk a f)) ?mk.v

tactic: apply Wequiv.abs'
state_before: case mk.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ Wequiv (Wrepr (WType.mk a f)) (PFunctor.W.mk (Wrepr <$> { fst := a, snd := f }))

tactic: have : Wrepr ⟨a, f⟩ = PFunctor.W.mk (repr (abs (Wrepr <$> ⟨a, f⟩))) := rfl
state_before: case mk.a.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
⊢ abs (PFunctor.W.dest (Wrepr (WType.mk a f))) =
    abs (PFunctor.W.dest (PFunctor.W.mk (Wrepr <$> { fst := a, snd := f })))

tactic: rw [this, PFunctor.W.dest_mk, abs_repr]
state_before: case mk.a.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
this : Wrepr (WType.mk a f) = PFunctor.W.mk (repr (abs (Wrepr <$> { fst := a, snd := f })))
⊢ abs (PFunctor.W.dest (Wrepr (WType.mk a f))) =
    abs (PFunctor.W.dest (PFunctor.W.mk (Wrepr <$> { fst := a, snd := f })))

tactic: rfl
state_before: case mk.a.h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
a : (P F).A
f : PFunctor.B (P F) a → WType (P F).B
ih : ∀ (a : PFunctor.B (P F) a), Wequiv (Wrepr (f a)) (f a)
this : Wrepr (WType.mk a f) = PFunctor.W.mk (repr (abs (Wrepr <$> { fst := a, snd := f })))
⊢ abs (Wrepr <$> { fst := a, snd := f }) = abs (PFunctor.W.dest (PFunctor.W.mk (Wrepr <$> { fst := a, snd := f })))
Theorem: Set.preimage_const_mul_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iio, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x x_1 => x * x_1) c ⁻¹' Ioo a b = Ioo (a / c) (b / c)
Theorem: countable_setOf_covby_left
File: Mathlib/Topology/Order/Basic.lean

tactic: convert @countable_setOf_covby_right αᵒᵈ _ _ _ _ using 5
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
⊢ Set.Countable {x | ∃ y, y ⋖ x}

tactic: exact toDual_covby_toDual_iff.symm
state_before: case h.e'_2.h.h.e'_2.h.h.h.e'_2.h.h.a
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
e_1✝² e_1✝¹ : α = αᵒᵈ
x✝¹ : α
e_1✝ : α = αᵒᵈ
x✝ : α
⊢ x✝ ⋖ x✝¹ ↔ x✝¹ ⋖ x✝
Theorem: Int.log_one_right
File: Mathlib/Data/Int/Log.lean

tactic: rw [log_of_one_le_right _ le_rfl, Nat.floor_one, Nat.log_one_right, Int.ofNat_zero]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
⊢ log b 1 = 0
Theorem: TendstoUniformly.tendstoUniformlyOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: rwa [← tendstoUniformly_iff_tendstoUniformlyOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
h : TendstoUniformly F f p
⊢ TendstoUniformlyOnFilter F f p ⊤
Theorem: Mathlib.Tactic.BicategoryCoherence.bicategoricalComp_refl
File: Mathlib/Tactic/CategoryTheory/BicategoryCoherence.lean

tactic: dsimp [bicategoricalComp]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ η ⊗≫ θ = η ≫ θ

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f g h : a ⟶ b
η : f ⟶ g
θ : g ⟶ h
⊢ η ≫ 𝟙 g ≫ θ = η ≫ θ
Theorem: SemiconjBy.div_right
File: Mathlib/Algebra/GroupWithZero/Semiconj.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv]
state_before: α : Type ?u.2687
M₀ : Type ?u.2690
G₀ : Type u_1
M₀' : Type ?u.2696
G₀' : Type ?u.2699
F : Type ?u.2702
F' : Type ?u.2705
inst✝ : GroupWithZero G₀
a x y x' y' : G₀
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x / x') (y / y')

tactic: exact h.mul_right h'.inv_right₀
state_before: α : Type ?u.2687
M₀ : Type ?u.2690
G₀ : Type u_1
M₀' : Type ?u.2696
G₀' : Type ?u.2699
F : Type ?u.2702
F' : Type ?u.2705
inst✝ : GroupWithZero G₀
a x y x' y' : G₀
h : SemiconjBy a x y
h' : SemiconjBy a x' y'
⊢ SemiconjBy a (x * x'⁻¹) (y * y'⁻¹)
Theorem: List.dlookup_kinsert_ne
File: Mathlib/Data/List/Sigma.lean

tactic: simp [h]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b' : β a'
l : List (Sigma β)
h : a ≠ a'
⊢ dlookup a (kinsert a' b' l) = dlookup a l
Theorem: Nat.not_bddAbove_setOf_prime
File: Mathlib/Data/Nat/Prime.lean

tactic: rw [not_bddAbove_iff]
state_before: ⊢ ¬BddAbove {p | Prime p}

tactic: intro n
state_before: ⊢ ∀ (x : ℕ), ∃ y, y ∈ {p | Prime p} ∧ x < y

tactic: obtain ⟨p, hi, hp⟩ := exists_infinite_primes n.succ
state_before: n : ℕ
⊢ ∃ y, y ∈ {p | Prime p} ∧ n < y

tactic: exact ⟨p, hp, hi⟩
state_before: case intro.intro
n p : ℕ
hi : succ n ≤ p
hp : Prime p
⊢ ∃ y, y ∈ {p | Prime p} ∧ n < y
Theorem: HasFDerivAt.smul_const
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

tactic: simpa only [smul_zero, zero_add] using hc.smul (hasFDerivAt_const f x)
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type ?u.594580
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
G' : Type ?u.594675
inst✝⁵ : NormedAddCommGroup G'
inst✝⁴ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
𝕜' : Type u_3
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : E → 𝕜'
c' : E →L[𝕜] 𝕜'
hc : HasFDerivAt c c' x
f : F
⊢ HasFDerivAt (fun y => c y • f) (smulRight c' f) x
Theorem: FractionalIdeal.coeToSubmodule_eq_bot
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp [h]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
h : ↑I = ⊥
⊢ (fun I => ↑I) I = (fun I => ↑I) 0

tactic: simp [h]
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I : FractionalIdeal S P
h : I = 0
⊢ ↑I = ⊥
Theorem: Set.eq_of_Ico_disjoint
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: rw [Ico_disjoint_Ico, min_eq_left (le_of_lt h2.2), le_max_iff] at h
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ x₁ x₂ y₁ y₂ : α
h : Disjoint (Ico x₁ x₂) (Ico y₁ y₂)
hx : x₁ < x₂
h2 : x₂ ∈ Ico y₁ y₂
⊢ y₁ = x₂

tactic: apply le_antisymm h2.1
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ x₁ x₂ y₁ y₂ : α
h : x₂ ≤ x₁ ∨ x₂ ≤ y₁
hx : x₁ < x₂
h2 : x₂ ∈ Ico y₁ y₂
⊢ y₁ = x₂

tactic: exact h.elim (fun h => absurd hx (not_lt_of_le h)) id
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
a₁ a₂ b₁ b₂ x₁ x₂ y₁ y₂ : α
h : x₂ ≤ x₁ ∨ x₂ ≤ y₁
hx : x₁ < x₂
h2 : x₂ ∈ Ico y₁ y₂
⊢ x₂ ≤ y₁
Theorem: Compactum.join_distrib
File: Mathlib/Topology/Category/Compactum.lean

tactic: change ((β ).μ.app _ ≫ X.a) _ = _
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ str X (join X uux) = str X (Ultrafilter.map (str X) uux)

tactic: rw [Monad.Algebra.assoc]
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ ((Monad.μ β).app X.A ≫ X.a) uux = str X (Ultrafilter.map (str X) uux)

tactic: rfl
state_before: X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.toFunctor.map X.a ≫ X.a) uux = str X (Ultrafilter.map (str X) uux)
Theorem: Bool.xor_assoc
File: Mathlib/Data/Bool/Basic.lean

tactic: decide
state_before: ⊢ ∀ (a b c : Bool), xor (xor a b) c = xor a (xor b c)