tasksource/leandojo huggingface dataset:
Theorem: LieSubmodule.ucs_mono
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
k : ℕ
h : N₁ ≤ N₂
⊢ ucs k N₁ ≤ ucs k N₂

tactic: simp only [ucs_succ]
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
k : ℕ
ih : ucs k N₁ ≤ ucs k N₂
⊢ ucs (Nat.succ k) N₁ ≤ ucs (Nat.succ k) N₂

tactic: apply monotone_normalizer ih
state_before: case succ
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k✝ : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
k : ℕ
ih : ucs k N₁ ≤ ucs k N₂
⊢ normalizer (ucs k N₁) ≤ normalizer (ucs k N₂)

tactic: simpa
state_before: case zero
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
k : ℕ
N N₁ N₂ : LieSubmodule R L M
h : N₁ ≤ N₂
⊢ ucs Nat.zero N₁ ≤ ucs Nat.zero N₂
Theorem: StrictConvexOn.translate_right
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm, Convex.combo_self hab]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.700544
α : Type ?u.700547
β : Type u_3
ι : Type ?u.700553
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCancelCommMonoid E
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : SMul 𝕜 β
s : Set E
f : E → β
hf : StrictConvexOn 𝕜 s f
c x : E
hx : x ∈ (fun z => c + z) ⁻¹' s
y : E
hy : y ∈ (fun z => c + z) ⁻¹' s
hxy : x ≠ y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ f (c + (a • x + b • y)) = f (a • (c + x) + b • (c + y))
Theorem: TopCat.coequalizer_isOpen_iff
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: rw [colimit_isOpen_iff]
state_before: J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen U ↔ IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)

tactic: constructor
state_before: J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ (∀ (j : WalkingParallelPair), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)) ↔
    IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)

tactic: intro H
state_before: case mp
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ (∀ (j : WalkingParallelPair), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)) →
    IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)

tactic: exact H _
state_before: case mp
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
H : ∀ (j : WalkingParallelPair), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)
⊢ IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)

tactic: intro H j
state_before: case mpr
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
⊢ IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U) →
    ∀ (j : WalkingParallelPair), IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)

tactic: cases j
state_before: case mpr
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
H : IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)
j : WalkingParallelPair
⊢ IsOpen ((forget TopCat).map (colimit.ι F j) ⁻¹' U)

tactic: rw [← colimit.w F WalkingParallelPairHom.left]
state_before: case mpr.zero
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
H : IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)
⊢ IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.zero) ⁻¹' U)

tactic: exact (F.map WalkingParallelPairHom.left).continuous_toFun.isOpen_preimage _ H
state_before: case mpr.zero
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
H : IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)
⊢ IsOpen ((forget TopCat).map (F.map WalkingParallelPairHom.left ≫ colimit.ι F WalkingParallelPair.one) ⁻¹' U)

tactic: exact H
state_before: case mpr.one
J : Type v
inst✝ : SmallCategory J
F : WalkingParallelPair ⥤ TopCat
U : Set ↑(colimit F)
H : IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)
⊢ IsOpen ((forget TopCat).map (colimit.ι F WalkingParallelPair.one) ⁻¹' U)
Theorem: Substring.ValidFor.takeWhile
File: Std/Data/String/Lemmas.lean

tactic: simp only [Substring.takeWhile, takeWhileAux_of_valid]
state_before: l m r : List Char
p : Char → Bool
⊢ ValidFor l (List.takeWhile p m) (List.dropWhile p m ++ r)
    (Substring.takeWhile
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
        stopPos := { byteIdx := utf8Len l + utf8Len m } }
      p)

tactic: refine' .of_eq .. <;> simp
state_before: l m r : List Char
p : Char → Bool
⊢ ValidFor l (List.takeWhile p m) (List.dropWhile p m ++ r)
    { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
      stopPos := { byteIdx := utf8Len l + utf8Len (List.takeWhile p m) } }

tactic: rw [← List.append_assoc, List.takeWhile_append_dropWhile]
state_before: case refine'_1
l m r : List Char
p : Char → Bool
⊢ m ++ r = List.takeWhile p m ++ (List.dropWhile p m ++ r)
Theorem: Substring.ValidFor.any
File: Std/Data/String/Lemmas.lean

tactic: simp [-List.append_assoc, Substring.any, anyAux_of_valid]
state_before: l m r : List Char
f : Char → Bool
⊢ Substring.any
      { str := { data := l ++ m ++ r }, startPos := { byteIdx := utf8Len l },
        stopPos := { byteIdx := utf8Len l + utf8Len m } }
      f =
    List.any m f
Theorem: Real.sign_int_cast
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy z (0 : ℤ)
state_before: z : ℤ
⊢ sign ↑z = ↑(Int.sign z)

tactic: rw [sign_of_neg (Int.cast_lt_zero.mpr hn), Int.sign_eq_neg_one_of_neg hn, Int.cast_neg,
  Int.cast_one]
state_before: case inl
z : ℤ
hn : z < 0
⊢ sign ↑z = ↑(Int.sign z)

tactic: rw [Int.cast_zero, sign_zero, Int.sign_zero, Int.cast_zero]
state_before: case inr.inl

⊢ sign ↑0 = ↑(Int.sign 0)

tactic: rw [sign_of_pos (Int.cast_pos.mpr hp), Int.sign_eq_one_of_pos hp, Int.cast_one]
state_before: case inr.inr
z : ℤ
hp : 0 < z
⊢ sign ↑z = ↑(Int.sign z)
Theorem: Multiset.sub_eq_fold_erase
File: Mathlib/Data/Multiset/Basic.lean

tactic: show ofList (l₁.diff l₂) = foldl erase erase_comm l₁ l₂
state_before: α : Type u_1
β : Type ?u.160973
γ : Type ?u.160976
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
l₁ l₂ : List α
⊢ Quotient.mk (isSetoid α) l₁ - Quotient.mk (isSetoid α) l₂ =
    foldl erase (_ : ∀ (s : Multiset α) (a b : α), erase (erase s a) b = erase (erase s b) a)
      (Quotient.mk (isSetoid α) l₁) (Quotient.mk (isSetoid α) l₂)

tactic: rw [diff_eq_foldl l₁ l₂]
state_before: α : Type u_1
β : Type ?u.160973
γ : Type ?u.160976
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
l₁ l₂ : List α
⊢ ↑(List.diff l₁ l₂) = foldl erase (_ : ∀ (s : Multiset α) (a b : α), erase (erase s a) b = erase (erase s b) a) ↑l₁ ↑l₂

tactic: symm
state_before: α : Type u_1
β : Type ?u.160973
γ : Type ?u.160976
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
l₁ l₂ : List α
⊢ ↑(List.foldl List.erase l₁ l₂) =
    foldl erase (_ : ∀ (s : Multiset α) (a b : α), erase (erase s a) b = erase (erase s b) a) ↑l₁ ↑l₂

tactic: exact foldl_hom _ _ _ _ _ fun x y => rfl
state_before: α : Type u_1
β : Type ?u.160973
γ : Type ?u.160976
inst✝ : DecidableEq α
s✝ t✝ u : Multiset α
a b : α
s t : Multiset α
l₁ l₂ : List α
⊢ foldl erase (_ : ∀ (s : Multiset α) (a b : α), erase (erase s a) b = erase (erase s b) a) ↑l₁ ↑l₂ =
    ↑(List.foldl List.erase l₁ l₂)
Theorem: Finset.nodup_toList
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [toList, ← Multiset.coe_nodup, Multiset.coe_toList]
state_before: α : Type u_1
β : Type ?u.479712
γ : Type ?u.479715
s : Finset α
⊢ List.Nodup (toList s)

tactic: exact s.nodup
state_before: α : Type u_1
β : Type ?u.479712
γ : Type ?u.479715
s : Finset α
⊢ Nodup s.val
Theorem: Function.minimalPeriod_apply_iterate
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply
  (IsPeriodicPt.minimalPeriod_le (minimalPeriod_pos_of_mem_periodicPts hx) _).antisymm
    ((isPeriodicPt_of_mem_periodicPts_of_isPeriodicPt_iterate hx
          (isPeriodicPt_minimalPeriod f _)).minimalPeriod_le
      (minimalPeriod_pos_of_mem_periodicPts _))
state_before: α : Type u_1
β : Type ?u.23216
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ minimalPeriod f ((f^[n]) x) = minimalPeriod f x

tactic: exact (isPeriodicPt_minimalPeriod f x).apply_iterate n
state_before: α : Type u_1
β : Type ?u.23216
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ IsPeriodicPt f (minimalPeriod f x) ((f^[n]) x)

tactic: rcases hx with ⟨m, hm, hx⟩
state_before: α : Type u_1
β : Type ?u.23216
f fa : α → α
fb : β → β
x y : α
m n✝ : ℕ
hx : x ∈ periodicPts f
n : ℕ
⊢ (f^[n]) x ∈ periodicPts f

tactic: exact ⟨m, hm, hx.apply_iterate n⟩
state_before: case intro.intro
α : Type u_1
β : Type ?u.23216
f fa : α → α
fb : β → β
x y : α
m✝ n✝ n m : ℕ
hm : m > 0
hx : IsPeriodicPt f m x
⊢ (f^[n]) x ∈ periodicPts f
Theorem: FiniteField.frobenius_pow
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: ext x
state_before: K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
hcard : q = p ^ n
⊢ frobenius K p ^ n = 1

tactic: conv_rhs => rw [RingHom.one_def, RingHom.id_apply, ← pow_card x, hcard]
state_before: case a
K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
hcard : q = p ^ n
x : K
⊢ ↑(frobenius K p ^ n) x = ↑1 x

tactic: clear hcard
state_before: case a
K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
hcard : q = p ^ n
x : K
⊢ ↑(frobenius K p ^ n) x = x ^ p ^ n

tactic: induction' n with n hn
state_before: case a
K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
n : ℕ
x : K
⊢ ↑(frobenius K p ^ n) x = x ^ p ^ n

tactic: simp
state_before: case a.zero
K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
⊢ ↑(frobenius K p ^ Nat.zero) x = x ^ p ^ Nat.zero

tactic: rw [pow_succ, pow_succ', pow_mul, RingHom.mul_def, RingHom.comp_apply, frobenius_def, hn]
state_before: case a.succ
K : Type u_1
R : Type ?u.742366
inst✝⁵ : Field K
inst✝⁴ : Fintype K
p✝ : ℕ
inst✝³ : Fact (Nat.Prime p✝)
inst✝² : Algebra (ZMod p✝) K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x : K
n : ℕ
hn : ↑(frobenius K p ^ n) x = x ^ p ^ n
⊢ ↑(frobenius K p ^ Nat.succ n) x = x ^ p ^ Nat.succ n
Theorem: closure_prod_eq
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [mem_prod, mem_closure_iff_nhdsWithin_neBot, nhdsWithin_prod_eq, prod_neBot]
state_before: α : Type u
β : Type v
γ : Type ?u.59142
δ : Type ?u.59145
ε : Type ?u.59148
ζ : Type ?u.59151
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set α
t : Set β
x✝ : α × β
a : α
b : β
⊢ (a, b) ∈ closure (s ×ˢ t) ↔ (a, b) ∈ closure s ×ˢ closure t
Theorem: Option.pbind_map
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.6432
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : α → β
x : Option α
g : (b : β) → b ∈ Option.map f x → Option γ
⊢ pbind (Option.map f x) g = pbind x fun a h => g (f a) (_ : f a ∈ Option.map f x)
Theorem: Set.mulIndicator_inter_mulSupport
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: rw [← mulIndicator_mulIndicator, mulIndicator_mulSupport]
state_before: α : Type u_1
β : Type ?u.15893
ι : Type ?u.15896
M : Type u_2
N : Type ?u.15902
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f✝ g : α → M
a : α
s : Set α
f : α → M
⊢ mulIndicator (s ∩ mulSupport f) f = mulIndicator s f
Theorem: Int.one_le_ceil_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← zero_add (1 : ℤ), add_one_le_ceil_iff, cast_zero]
state_before: F : Type ?u.209524
α : Type u_1
β : Type ?u.209530
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ 1 ≤ ⌈a⌉ ↔ 0 < a
Theorem: PythagoreanTriple.isPrimitiveClassified_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: by_cases hz : 0 < z
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ IsPrimitiveClassified h

tactic: have h' : PythagoreanTriple x y (-z) := by simpa [PythagoreanTriple, neg_mul_neg] using h.eq
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : ¬0 < z
⊢ IsPrimitiveClassified h

tactic: apply h'.isPrimitiveClassified_of_coprime_of_pos hc
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ IsPrimitiveClassified h

tactic: apply lt_of_le_of_ne _ (h'.ne_zero_of_coprime hc).symm
state_before: case neg
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 < -z

tactic: exact le_neg.mp (not_lt.mp hz)
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : ¬0 < z
h' : PythagoreanTriple x y (-z)
⊢ 0 ≤ -z

tactic: exact h.isPrimitiveClassified_of_coprime_of_pos hc hz
state_before: case pos
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : 0 < z
⊢ IsPrimitiveClassified h

tactic: simpa [PythagoreanTriple, neg_mul_neg] using h.eq
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hz : ¬0 < z
⊢ PythagoreanTriple x y (-z)
Theorem: right_vsub_midpoint
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint_comm, left_vsub_midpoint]
state_before: R : Type u_3
V : Type u_1
V' : Type ?u.52855
P : Type u_2
P' : Type ?u.52861
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z p₁ p₂ : P
⊢ p₂ -ᵥ midpoint R p₁ p₂ = ⅟2 • (p₂ -ᵥ p₁)
Theorem: Real.logb_le_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_le_div_right (log_pos hb), log_le_log h h₁]
state_before: b x y : ℝ
hb : 1 < b
h : 0 < x
h₁ : 0 < y
⊢ logb b x ≤ logb b y ↔ x ≤ y
Theorem: Computation.rel_of_LiftRel
File: Mathlib/Data/Seq/Computation.lean

tactic: let ⟨b', mb', ab'⟩ := l ma
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
⊢ R a b

tactic: rw [mem_unique mb mb']
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b

tactic: exact ab'
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
ca : Computation α
cb : Computation β
l : ∀ {a : α}, a ∈ ca → ∃ b, b ∈ cb ∧ R a b
right✝ : ∀ {b : β}, b ∈ cb → ∃ a, a ∈ ca ∧ R a b
a : α
b : β
ma : a ∈ ca
mb : b ∈ cb
b' : β
mb' : b' ∈ cb
ab' : R a b'
⊢ R a b'
Theorem: CauSeq.Completion.mul_inv_cancel
File: Mathlib/Data/Real/CauSeqCompletion.lean

tactic: simp only [mk_eq_mk, ne_eq, mk_eq_zero] at hf
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : Quotient.mk equiv f ≠ 0
⊢ Quotient.mk equiv f * (Quotient.mk equiv f)⁻¹ = 1

tactic: simp [hf]
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬LimZero f
⊢ Quotient.mk equiv f * (Quotient.mk equiv f)⁻¹ = 1

tactic: exact Quotient.sound (CauSeq.mul_inv_cancel hf)
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬LimZero f
⊢ mk (f * inv f (_ : ¬LimZero f)) = 1
Theorem: FreimanHom.cancel_right_on
File: Mathlib/Algebra/Hom/Freiman.lean

tactic: simp [hf.cancel_right hf']
state_before: F : Type ?u.51726
α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.51738
G : Type ?u.51741
inst✝⁵ : FunLike F α fun x => β
inst✝⁴ : CommMonoid α
inst✝³ : CommMonoid β
inst✝² : CommMonoid γ
inst✝¹ : CommMonoid δ
inst✝ : CommGroup G
A : Set α
B : Set β
C : Set γ
n : ℕ
a b c d : α
g₁ g₂ : B →*[n] γ
f : A →*[n] β
hf : Set.SurjOn (↑f) A B
hf' : Set.MapsTo (↑f) A B
⊢ Set.EqOn (↑(FreimanHom.comp g₁ f hf')) (↑(FreimanHom.comp g₂ f hf')) A ↔ Set.EqOn (↑g₁) (↑g₂) B
Theorem: EuclideanGeometry.orthogonalProjectionFn_mem_orthogonal
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: rw [← mem_coe, ← Set.singleton_subset_iff, ← inter_eq_singleton_orthogonalProjectionFn]
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ orthogonalProjectionFn s p ∈ mk' p (direction s)ᗮ

tactic: exact Set.inter_subset_right _ _
state_before: V : Type u_1
P : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : InnerProductSpace ℝ V
inst✝³ : MetricSpace P
inst✝² : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
p : P
⊢ ↑s ∩ ↑(mk' p (direction s)ᗮ) ⊆ ↑(mk' p (direction s)ᗮ)
Theorem: hasCompactMulSupport_def
File: Mathlib/Topology/Support.lean

tactic: rfl
state_before: X : Type ?u.8941
α : Type u_1
α' : Type ?u.8947
β : Type u_2
γ : Type ?u.8953
δ : Type ?u.8956
M : Type ?u.8959
E : Type ?u.8962
R : Type ?u.8965
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace α'
inst✝² : One β
inst✝¹ : One γ
inst✝ : One δ
g : β → γ
f : α → β
f₂ : α → γ
m : β → γ → δ
x : α
⊢ HasCompactMulSupport f ↔ IsCompact (closure (mulSupport f))
Theorem: FractionalIdeal.isFractional_of_le_one
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: use 1, S.one_mem
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 : Submodule R P
h : I ≤ 1
⊢ IsFractional S I

tactic: intro b hb
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 : Submodule R P
h : I ≤ 1
⊢ ∀ (b : P), b ∈ I → IsInteger R (1 • b)

tactic: rw [one_smul]
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 : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R (1 • b)

tactic: obtain ⟨b', b'_mem, rfl⟩ := h hb
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 : Submodule R P
h : I ≤ 1
b : P
hb : b ∈ I
⊢ IsInteger R b

tactic: exact Set.mem_range_self b'
state_before: case intro.refl
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 : Submodule R P
h : I ≤ 1
b' : R
hb : ↑(Algebra.linearMap R P) b' ∈ I
⊢ IsInteger R (↑(Algebra.linearMap R P) b')
Theorem: continuous_if_const
File: Mathlib/Topology/ContinuousOn.lean

tactic: split_ifs with h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.383429
δ : Type ?u.383432
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : Prop
f g : α → β
inst✝ : Decidable p
hf : p → Continuous f
hg : ¬p → Continuous g
⊢ Continuous fun a => if p then f a else g a

tactic: exacts [hf h, hg h]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type ?u.383429
δ : Type ?u.383432
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : Prop
f g : α → β
inst✝ : Decidable p
hf : p → Continuous f
hg : ¬p → Continuous g
h : p
⊢ Continuous fun a => f a

case inr
α : Type u_1
β : Type u_2
γ : Type ?u.383429
δ : Type ?u.383432
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
p : Prop
f g : α → β
inst✝ : Decidable p
hf : p → Continuous f
hg : ¬p → Continuous g
h : ¬p
⊢ Continuous fun a => g a
Theorem: StrictConvex.linear_image
File: Mathlib/Analysis/Convex/Strict.lean

tactic: rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ hxy a b ha hb hab
state_before: 𝕜 : Type u_4
𝕝 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.14448
inst✝¹⁰ : OrderedSemiring 𝕜
inst✝⁹ : TopologicalSpace E
inst✝⁸ : TopologicalSpace F
inst✝⁷ : AddCommMonoid E
inst✝⁶ : AddCommMonoid F
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module 𝕜 F
s : Set E
inst✝³ : Semiring 𝕝
inst✝² : Module 𝕝 E
inst✝¹ : Module 𝕝 F
inst✝ : LinearMap.CompatibleSMul E F 𝕜 𝕝
hs : StrictConvex 𝕜 s
f : E →ₗ[𝕝] F
hf : IsOpenMap ↑f
⊢ StrictConvex 𝕜 (↑f '' s)

tactic: refine' hf.image_interior_subset _ ⟨a • x + b • y, hs hx hy (ne_of_apply_ne _ hxy) ha hb hab, _⟩
state_before: case intro.intro.intro.intro
𝕜 : Type u_4
𝕝 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.14448
inst✝¹⁰ : OrderedSemiring 𝕜
inst✝⁹ : TopologicalSpace E
inst✝⁸ : TopologicalSpace F
inst✝⁷ : AddCommMonoid E
inst✝⁶ : AddCommMonoid F
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module 𝕜 F
s : Set E
inst✝³ : Semiring 𝕝
inst✝² : Module 𝕝 E
inst✝¹ : Module 𝕝 F
inst✝ : LinearMap.CompatibleSMul E F 𝕜 𝕝
hs : StrictConvex 𝕜 s
f : E →ₗ[𝕝] F
hf : IsOpenMap ↑f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : ↑f x ≠ ↑f y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • ↑f x + b • ↑f y ∈ interior (↑f '' s)

tactic: rw [map_add, f.map_smul_of_tower a, f.map_smul_of_tower b]
state_before: case intro.intro.intro.intro
𝕜 : Type u_4
𝕝 : Type u_1
E : Type u_2
F : Type u_3
β : Type ?u.14448
inst✝¹⁰ : OrderedSemiring 𝕜
inst✝⁹ : TopologicalSpace E
inst✝⁸ : TopologicalSpace F
inst✝⁷ : AddCommMonoid E
inst✝⁶ : AddCommMonoid F
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module 𝕜 F
s : Set E
inst✝³ : Semiring 𝕝
inst✝² : Module 𝕝 E
inst✝¹ : Module 𝕝 F
inst✝ : LinearMap.CompatibleSMul E F 𝕜 𝕝
hs : StrictConvex 𝕜 s
f : E →ₗ[𝕝] F
hf : IsOpenMap ↑f
x : E
hx : x ∈ s
y : E
hy : y ∈ s
hxy : ↑f x ≠ ↑f y
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ ↑f (a • x + b • y) = a • ↑f x + b • ↑f y
Theorem: MeasureTheory.L1.setToFun_eq_setToL1
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: rw [setToFun_eq hT (L1.integrable_coeFn f), Integrable.toL1_coeFn]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1320608
G : Type ?u.1320611
𝕜 : Type ?u.1320614
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
f : { x // x ∈ Lp E 1 }
⊢ setToFun μ T hT ↑↑f = ↑(setToL1 hT) f