tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.isIso_left_of_isIso_biprod_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: have t := congrArg (fun p : W ⊞ X ⟶ W ⊞ X => biprod.inl ≫ p ≫ biprod.fst)
  (IsIso.hom_inv_id (biprod.map f g))
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W

tactic: simp only [Category.id_comp, Category.assoc, biprod.inl_map_assoc] at t
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t :
  (fun p => biprod.inl ≫ p ≫ biprod.fst) (biprod.map f g ≫ inv (biprod.map f g)) =
    (fun p => biprod.inl ≫ p ≫ biprod.fst) (𝟙 (W ⊞ X))
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W

tactic: simp [t]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = biprod.inl ≫ biprod.fst
⊢ f ≫ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst = 𝟙 W

tactic: have t := congrArg (fun p : Y ⊞ Z ⟶ Y ⊞ Z => biprod.inl ≫ p ≫ biprod.fst)
  (IsIso.inv_hom_id (biprod.map f g))
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y

tactic: simp only [Category.id_comp, Category.assoc, biprod.map_fst] at t
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t :
  (fun p => biprod.inl ≫ p ≫ biprod.fst) (inv (biprod.map f g) ≫ biprod.map f g) =
    (fun p => biprod.inl ≫ p ≫ biprod.fst) (𝟙 (Y ⊞ Z))
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y

tactic: simp only [Category.assoc]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = biprod.inl ≫ biprod.fst
⊢ (biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst) ≫ f = 𝟙 Y

tactic: simp [t]
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasBinaryBiproducts C
W X Y Z : C
f : W ⟶ Y
g : X ⟶ Z
inst✝ : IsIso (biprod.map f g)
t : biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = biprod.inl ≫ biprod.fst
⊢ biprod.inl ≫ inv (biprod.map f g) ≫ biprod.fst ≫ f = 𝟙 Y
Theorem: Finset.range_add_one'
File: Mathlib/Data/Finset/Image.lean

tactic: simp
state_before: α : Type ?u.55329
β : Type ?u.55332
γ : Type ?u.55335
n i j : ℕ
⊢ (fun i => i + 1) i = (fun i => i + 1) j → i = j

tactic: ext (⟨⟩ | ⟨n⟩) <;> simp [Nat.succ_eq_add_one, Nat.zero_lt_succ n]
state_before: α : Type ?u.55329
β : Type ?u.55332
γ : Type ?u.55335
n : ℕ
⊢ range (n + 1) = insert 0 (map { toFun := fun i => i + 1, inj' := (_ : ∀ (i j : ℕ), i + 1 = j + 1 → i = j) } (range n))
Theorem: Real.arccos_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos, add_halves]
state_before: ⊢ arccos (-1) = π
Theorem: SemidirectProduct.map_inr
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: simp [map]
state_before: N : Type u_3
G : Type u_4
H : Type ?u.259984
inst✝⁴ : Group N
inst✝³ : Group G
inst✝² : Group H
φ : G →* MulAut N
N₁ : Type u_1
G₁ : Type u_2
inst✝¹ : Group N₁
inst✝ : Group G₁
φ₁ : G₁ →* MulAut N₁
f₁ : N →* N₁
f₂ : G →* G₁
h : ∀ (g : G), MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑φ₁ (↑f₂ g))) f₁
g : G
⊢ ↑(map f₁ f₂ h) (↑inr g) = ↑inr (↑f₂ g)
Theorem: Finset.one_lt_card_iff
File: Mathlib/Data/Finset/Card.lean

tactic: rw [one_lt_card]
state_before: α : Type u_1
β : Type ?u.55605
s t : Finset α
f : α → β
n : ℕ
⊢ 1 < card s ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b

tactic: simp only [exists_prop, exists_and_left]
state_before: α : Type u_1
β : Type ?u.55605
s t : Finset α
f : α → β
n : ℕ
⊢ (∃ a, a ∈ s ∧ ∃ b, b ∈ s ∧ a ≠ b) ↔ ∃ a b, a ∈ s ∧ b ∈ s ∧ a ≠ b
Theorem: AffineSubspace.direction_lt_of_nonempty
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: cases' hn with p hp
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h : s1 < s2
hn : Set.Nonempty ↑s1
⊢ direction s1 < direction s2

tactic: rw [lt_iff_le_and_exists] at h
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h : s1 < s2
p : P
hp : p ∈ ↑s1
⊢ direction s1 < direction s2

tactic: rcases h with ⟨hle, p2, hp2, hp2s1⟩
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
h : s1 ≤ s2 ∧ ∃ p, p ∈ s2 ∧ ¬p ∈ s1
p : P
hp : p ∈ ↑s1
⊢ direction s1 < direction s2

tactic: rw [SetLike.lt_iff_le_and_exists]
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
p : P
hp : p ∈ ↑s1
hle : s1 ≤ s2
p2 : P
hp2 : p2 ∈ s2
hp2s1 : ¬p2 ∈ s1
⊢ direction s1 < direction s2

tactic: use direction_le hle, p2 -ᵥ p, vsub_mem_direction hp2 (hle hp)
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
p : P
hp : p ∈ ↑s1
hle : s1 ≤ s2
p2 : P
hp2 : p2 ∈ s2
hp2s1 : ¬p2 ∈ s1
⊢ direction s1 ≤ direction s2 ∧ ∃ x, x ∈ direction s2 ∧ ¬x ∈ direction s1

tactic: intro hm
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
p : P
hp : p ∈ ↑s1
hle : s1 ≤ s2
p2 : P
hp2 : p2 ∈ s2
hp2s1 : ¬p2 ∈ s1
⊢ ¬p2 -ᵥ p ∈ direction s1

tactic: rw [vsub_right_mem_direction_iff_mem hp p2] at hm
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
p : P
hp : p ∈ ↑s1
hle : s1 ≤ s2
p2 : P
hp2 : p2 ∈ s2
hp2s1 : ¬p2 ∈ s1
hm : p2 -ᵥ p ∈ direction s1
⊢ False

tactic: exact hp2s1 hm
state_before: case intro.intro.intro.intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s1 s2 : AffineSubspace k P
p : P
hp : p ∈ ↑s1
hle : s1 ≤ s2
p2 : P
hp2 : p2 ∈ s2
hp2s1 : ¬p2 ∈ s1
hm : p2 ∈ s1
⊢ False
Theorem: Metric.denseRange_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [mem_closure_iff, exists_range_iff]
state_before: α : Type u
β : Type v
X : Type ?u.306971
ι : Type ?u.306974
inst✝ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s : Set α
f : β → α
x : α
⊢ x ∈ closure (range f) ↔ ∀ (r : ℝ), r > 0 → ∃ y, dist x (f y) < r
Theorem: Complex.arg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simp [arg, le_refl]
state_before: ⊢ arg I = π / 2
Theorem: Matrix.nondegenerate_toBilin_iff
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [← Matrix.nondegenerate_toBilin'_iff_nondegenerate_toBilin, Matrix.nondegenerate_toBilin'_iff]
state_before: R : Type ?u.2835547
M✝ : Type ?u.2835550
inst✝¹⁹ : Semiring R
inst✝¹⁸ : AddCommMonoid M✝
inst✝¹⁷ : Module R M✝
R₁ : Type ?u.2835586
M₁ : Type ?u.2835589
inst✝¹⁶ : Ring R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type ?u.2836198
M₂ : Type ?u.2836201
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type u_2
M₃ : Type u_3
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type ?u.2836979
K : Type ?u.2836982
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B : BilinForm R M✝
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type ?u.2838196
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
M : Matrix ι ι R₃
b : Basis ι R₃ M₃
⊢ Nondegenerate (↑(toBilin b) M) ↔ Matrix.Nondegenerate M
Theorem: Set.finite_subset_iUnion
File: Mathlib/Data/Set/Finite.lean

tactic: cases hs
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
hs : Set.Finite s
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
⊢ ∃ I, Set.Finite I ∧ s ⊆ ⋃ (i : ι) (_ : i ∈ I), t i

tactic: choose f hf using show ∀ x : s, ∃ i, x.1 ∈ t i by simpa [subset_def] using h
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
a✝ : Fintype ↑s
⊢ ∃ I, Set.Finite I ∧ s ⊆ ⋃ (i : ι) (_ : i ∈ I), t i

tactic: refine' ⟨range f, finite_range f, fun x hx => _⟩
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
a✝ : Fintype ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
⊢ ∃ I, Set.Finite I ∧ s ⊆ ⋃ (i : ι) (_ : i ∈ I), t i

tactic: rw [biUnion_range, mem_iUnion]
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
a✝ : Fintype ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ x ∈ ⋃ (i : ι) (_ : i ∈ range f), t i

tactic: exact ⟨⟨x, hx⟩, hf _⟩
state_before: case intro
α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
a✝ : Fintype ↑s
f : ↑s → ι
hf : ∀ (x : ↑s), ↑x ∈ t (f x)
x : α
hx : x ∈ s
⊢ ∃ i, x ∈ t (f i)

tactic: simpa [subset_def] using h
state_before: α : Type u
β : Type v
ι✝ : Sort w
γ : Type x
s : Set α
ι : Type u_1
t : ι → Set α
h : s ⊆ ⋃ (i : ι), t i
a✝ : Fintype ↑s
⊢ ∀ (x : ↑s), ∃ i, ↑x ∈ t i
Theorem: MeasureTheory.Measure.toOuterMeasure_injective
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: congr
state_before: α : Type u_1
β : Type ?u.9151
γ : Type ?u.9154
δ : Type ?u.9157
ι : Type ?u.9160
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
x✝¹ x✝ : Measure α
m₁ : OuterMeasure α
u₁ :
  ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → ↑m₁ (⋃ (i : ℕ), f i) = ∑' (i : ℕ), ↑m₁ (f i)
h₁ : OuterMeasure.trim m₁ = m₁
m₂ : OuterMeasure α
_u₂ :
  ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → ↑m₂ (⋃ (i : ℕ), f i) = ∑' (i : ℕ), ↑m₂ (f i)
_h₂ : OuterMeasure.trim m₂ = m₂
_h :
  ↑{ toOuterMeasure := m₁, m_iUnion := u₁, trimmed := h₁ } = ↑{ toOuterMeasure := m₂, m_iUnion := _u₂, trimmed := _h₂ }
⊢ { toOuterMeasure := m₁, m_iUnion := u₁, trimmed := h₁ } = { toOuterMeasure := m₂, m_iUnion := _u₂, trimmed := _h₂ }
Theorem: List.diff_cons_right
File: Std/Data/List/Lemmas.lean

tactic: apply Eq.symm
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
a : α
⊢ List.diff l₁ (a :: l₂) = List.erase (List.diff l₁ l₂) a

tactic: induction l₂ generalizing l₁ <;> simp [erase_comm, *]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
a : α
⊢ List.erase (List.diff l₁ l₂) a = List.diff l₁ (a :: l₂)
Theorem: Hyperreal.infinite_mul_of_not_infinitesimal_infinite
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [mul_comm]
state_before: x y : ℝ*
hx : ¬Infinitesimal x
hy : Infinite y
⊢ Infinite (x * y)

tactic: exact infinite_mul_of_infinite_not_infinitesimal hy hx
state_before: x y : ℝ*
hx : ¬Infinitesimal x
hy : Infinite y
⊢ Infinite (y * x)
Theorem: Complex.normSq_ofReal
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [normSq, ofReal']
state_before: r : ℝ
⊢ ↑normSq ↑r = r * r
Theorem: IsAntichain.max_minimals
File: Mathlib/Order/Minimal.lean

tactic: refine' h.antisymm fun a ha => _
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a b : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ minimals r s ∧ r a b
⊢ minimals r s = t

tactic: obtain ⟨b, hb, hr⟩ := hs ha
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ minimals r s ∧ r a b
a : α
ha : a ∈ t
⊢ a ∈ minimals r s

tactic: rwa [of_not_not fun hab => ht ha (h hb) hab hr]
state_before: case intro.intro
α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
ht : IsAntichain r t
h : minimals r s ⊆ t
hs : ∀ ⦃a : α⦄, a ∈ t → ∃ b, b ∈ minimals r s ∧ r a b
a : α
ha : a ∈ t
b : α
hb : b ∈ minimals r s
hr : r a b
⊢ a ∈ minimals r s
Theorem: Fin.natAdd_cast
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' = n
⊢ ↑(natAdd m) (↑(cast h) i) = ↑(cast (_ : m + n' = m + n)) (↑(natAdd m) i)

tactic: simp
state_before: case h
n✝ m✝ n n' m : ℕ
i : Fin n'
h : n' = n
⊢ ↑(↑(natAdd m) (↑(cast h) i)) = ↑(↑(cast (_ : m + n' = m + n)) (↑(natAdd m) i))
Theorem: String.data_takeWhile
File: Std/Data/String/Lemmas.lean

tactic: rw [takeWhile_eq]
state_before: p : Char → Bool
s : String
⊢ (takeWhile s p).data = List.takeWhile p s.data
Theorem: finprod_mem_dvd
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: by_cases ha : a ∈ mulSupport f
state_before: α : Type u_1
β : Type ?u.347101
ι : Type ?u.347104
G : Type ?u.347107
M : Type ?u.347110
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : Set.Finite (mulSupport f)
⊢ f a ∣ finprod f

tactic: rw [finprod_eq_prod_of_mulSupport_toFinset_subset f hf (Set.Subset.refl _)]
state_before: case pos
α : Type u_1
β : Type ?u.347101
ι : Type ?u.347104
G : Type ?u.347107
M : Type ?u.347110
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : Set.Finite (mulSupport f)
ha : a ∈ mulSupport f
⊢ f a ∣ finprod f

tactic: exact Finset.dvd_prod_of_mem f ((Finite.mem_toFinset hf).mpr ha)
state_before: case pos
α : Type u_1
β : Type ?u.347101
ι : Type ?u.347104
G : Type ?u.347107
M : Type ?u.347110
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : Set.Finite (mulSupport f)
ha : a ∈ mulSupport f
⊢ f a ∣ ∏ i in Finite.toFinset hf, f i

tactic: rw [nmem_mulSupport.mp ha]
state_before: case neg
α : Type u_1
β : Type ?u.347101
ι : Type ?u.347104
G : Type ?u.347107
M : Type ?u.347110
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : Set.Finite (mulSupport f)
ha : ¬a ∈ mulSupport f
⊢ f a ∣ finprod f

tactic: exact one_dvd (finprod f)
state_before: case neg
α : Type u_1
β : Type ?u.347101
ι : Type ?u.347104
G : Type ?u.347107
M : Type ?u.347110
N : Type u_2
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : Set.Finite (mulSupport f)
ha : ¬a ∈ mulSupport f
⊢ 1 ∣ finprod f
Theorem: Mathlib.Meta.NormNum.isRat_lt_true
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: have h := Int.cast_strictMono (α := α) <| of_decide_eq_true h
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h : decide (num✝¹ * ↑db < num✝ * ↑da) = true
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db

tactic: have ha : 0 < ⅟(da : α) := pos_invOf_of_invertible_cast da
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝ : decide (num✝¹ * ↑db < num✝ * ↑da) = true
h : (fun x => ↑x) (num✝¹ * ↑db) < (fun x => ↑x) (num✝ * ↑da)
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db

tactic: have hb : 0 < ⅟(db : α) := pos_invOf_of_invertible_cast db
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝ : decide (num✝¹ * ↑db < num✝ * ↑da) = true
h : (fun x => ↑x) (num✝¹ * ↑db) < (fun x => ↑x) (num✝ * ↑da)
ha : 0 < ⅟↑da
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db

tactic: rw [← mul_assoc, Int.commute_cast] at h
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (num✝¹ * ↑db < num✝ * ↑da) = true
h✝ : (fun x => ↑x) (num✝¹ * ↑db) < (fun x => ↑x) (num✝ * ↑da)
ha : 0 < ⅟↑da
hb : 0 < ⅟↑db
h : ⅟↑db * ((fun x => ↑x) (num✝¹ * ↑db) * ⅟↑da) < ⅟↑db * ((fun x => ↑x) (num✝ * ↑da) * ⅟↑da)
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db

tactic: simp at h
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (num✝¹ * ↑db < num✝ * ↑da) = true
h✝ : (fun x => ↑x) (num✝¹ * ↑db) < (fun x => ↑x) (num✝ * ↑da)
ha : 0 < ⅟↑da
hb : 0 < ⅟↑db
h : ↑(num✝¹ * ↑db) * ⅟↑db * ⅟↑da < ⅟↑db * ((fun x => ↑x) (num✝ * ↑da) * ⅟↑da)
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db

tactic: rwa [Int.commute_cast] at h
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Nontrivial α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (num✝¹ * ↑db < num✝ * ↑da) = true
h✝ : (fun x => ↑x) (num✝¹ * ↑db) < (fun x => ↑x) (num✝ * ↑da)
ha : 0 < ⅟↑da
hb : 0 < ⅟↑db
h : ↑num✝¹ * ⅟↑da < ⅟↑db * ↑num✝
⊢ ↑num✝¹ * ⅟↑da < ↑num✝ * ⅟↑db
Theorem: Filter.blimsup_sup_le_or
File: Mathlib/Order/LiminfLimsup.lean

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.139592
ι : Type ?u.139595
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
⊢ ∀ (x : β), p x → p x ∨ q x

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.139592
ι : Type ?u.139595
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
⊢ ∀ (x : β), q x → p x ∨ q x
Theorem: Localization.liftOn_mk'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← mk_eq_monoidOf_mk', liftOn_mk]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.3266990
inst✝¹ : CommMonoid N
P : Type ?u.3266996
inst✝ : CommMonoid P
p : Sort u
f : M → { x // x ∈ S } → p
H : ∀ {a c : M} {b d : { x // x ∈ S }}, ↑(r S) (a, b) (c, d) → f a b = f c d
a : M
b : { x // x ∈ S }
⊢ liftOn (Submonoid.LocalizationMap.mk' (monoidOf S) a b) f H = f a b
Theorem: Real.Angle.sin_neg
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ sin (-θ) = -sin θ

tactic: exact Real.sin_neg _
state_before: case h
x✝ : ℝ
⊢ sin (-↑x✝) = -sin ↑x✝
Theorem: Projectivization.mk_eq_mk_iff'
File: Mathlib/LinearAlgebra/ProjectiveSpace/Basic.lean

tactic: rw [mk_eq_mk_iff K v w hv hw]
state_before: K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
⊢ mk K v hv = mk K w hw ↔ ∃ a, a • w = v

tactic: constructor
state_before: K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
⊢ (∃ a, a • w = v) ↔ ∃ a, a • w = v

tactic: rintro ⟨a, ha⟩
state_before: case mp
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
⊢ (∃ a, a • w = v) → ∃ a, a • w = v

tactic: exact ⟨a, ha⟩
state_before: case mp.intro
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
a : Kˣ
ha : a • w = v
⊢ ∃ a, a • w = v

tactic: rintro ⟨a, ha⟩
state_before: case mpr
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
⊢ (∃ a, a • w = v) → ∃ a, a • w = v

tactic: refine' ⟨Units.mk0 a fun c => hv.symm _, ha⟩
state_before: case mpr.intro
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
a : K
ha : a • w = v
⊢ ∃ a, a • w = v

tactic: rwa [c, zero_smul] at ha
state_before: case mpr.intro
K : Type u_2
V : Type u_1
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v w : V
hv : v ≠ 0
hw : w ≠ 0
a : K
ha : a • w = v
c : a = 0
⊢ 0 = v
Theorem: Relation.ReflTransGen.head
File: Mathlib/Logic/Relation.lean

tactic: induction hbc
state_before: α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c d : α
hab : r a b
hbc : ReflTransGen r b c
⊢ ReflTransGen r a c

tactic: case refl => exact refl.tail hab
state_before: case refl
α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c d : α
hab : r a b
⊢ ReflTransGen r a b

case tail
α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c d : α
hab : r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

tactic: case tail c d _ hcd hac => exact hac.tail hcd
state_before: case tail
α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c d : α
hab : r a b
b✝ c✝ : α
a✝¹ : ReflTransGen r b b✝
a✝ : r b✝ c✝
a_ih✝ : ReflTransGen r a b✝
⊢ ReflTransGen r a c✝

tactic: exact refl.tail hab
state_before: α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c d : α
hab : r a b
⊢ ReflTransGen r a b

tactic: exact hac.tail hcd
state_before: α : Type u_1
β : Type ?u.16575
γ : Type ?u.16578
δ : Type ?u.16581
r : α → α → Prop
a b c✝ d✝ : α
hab : r a b
c d : α
a✝ : ReflTransGen r b c
hcd : r c d
hac : ReflTransGen r a c
⊢ ReflTransGen r a d
Theorem: Matrix.TransvectionStruct.mul_inv
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: rcases t with ⟨_, _, t_hij⟩
state_before: n : Type u_1
p : Type ?u.34495
R : Type u₂
𝕜 : Type ?u.34500
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
t : TransvectionStruct n R
⊢ toMatrix t ⬝ toMatrix (TransvectionStruct.inv t) = 1

tactic: simp [toMatrix, transvection_mul_transvection_same, t_hij]
state_before: case mk
n : Type u_1
p : Type ?u.34495
R : Type u₂
𝕜 : Type ?u.34500
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
i✝ j✝ : n
t_hij : i✝ ≠ j✝
c✝ : R
⊢ toMatrix { i := i✝, j := j✝, hij := t_hij, c := c✝ } ⬝
      toMatrix (TransvectionStruct.inv { i := i✝, j := j✝, hij := t_hij, c := c✝ }) =
    1
Theorem: Set.nontrivial_coe_sort
File: Mathlib/Data/Set/Basic.lean

tactic: rw [← nontrivial_univ_iff, Set.Nontrivial, Set.Nontrivial]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ Nontrivial ↑s ↔ Set.Nontrivial s

tactic: apply Iff.intro
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ (∃ x x_1 y x_2, x ≠ y) ↔ ∃ x x_1 y x_2, x ≠ y

tactic: rintro ⟨x, _, y, _, hxy⟩
state_before: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ (∃ x x_1 y x_2, x ≠ y) → ∃ x x_1 y x_2, x ≠ y

tactic: exact ⟨x, Subtype.prop x, y, Subtype.prop y, fun h => hxy (Subtype.coe_injective h)⟩
state_before: case mp.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : ↑s
w✝¹ : x ∈ univ
y : ↑s
w✝ : y ∈ univ
hxy : x ≠ y
⊢ ∃ x x_1 y x_2, x ≠ y

tactic: rintro ⟨x, hx, y, hy, hxy⟩
state_before: case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
⊢ (∃ x x_1 y x_2, x ≠ y) → ∃ x x_1 y x_2, x ≠ y

tactic: exact ⟨⟨x, hx⟩, mem_univ _, ⟨y, hy⟩, mem_univ _, Subtype.mk_eq_mk.not.mpr hxy⟩
state_before: case mpr.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u s : Set α
x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
⊢ ∃ x x_1 y x_2, x ≠ y
Theorem: PadicInt.cast_toZModPow
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: rw [← zmod_cast_comp_toZModPow _ _ h]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
m n : ℕ
h : m ≤ n
x : ℤ_[p]
⊢ ↑(↑(toZModPow n) x) = ↑(toZModPow m) x

tactic: rfl
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
m n : ℕ
h : m ≤ n
x : ℤ_[p]
⊢ ↑(↑(toZModPow n) x) = ↑(RingHom.comp (ZMod.castHom (_ : p ^ m ∣ p ^ n) (ZMod (p ^ m))) (toZModPow n)) x